// Copyright 2016-2022 The Libsacloud Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// generated by 'github.com/sacloud/libsacloud/internal/tools/gen-api-stub'; DO NOT EDIT

package stub

import (
	"context"
	"log"

	"github.com/sacloud/libsacloud/v2/sacloud"
	"github.com/sacloud/libsacloud/v2/sacloud/types"
)

/*************************************************
* ArchiveStub
*************************************************/

// ArchiveFindStubResult is expected values of the Find operation
type ArchiveFindStubResult struct {
	Values *sacloud.ArchiveFindResult
	Err    error
}

// ArchiveCreateStubResult is expected values of the Create operation
type ArchiveCreateStubResult struct {
	Archive *sacloud.Archive
	Err     error
}

// ArchiveCreateBlankStubResult is expected values of the CreateBlank operation
type ArchiveCreateBlankStubResult struct {
	Archive   *sacloud.Archive
	FTPServer *sacloud.FTPServer
	Err       error
}

// ArchiveReadStubResult is expected values of the Read operation
type ArchiveReadStubResult struct {
	Archive *sacloud.Archive
	Err     error
}

// ArchiveUpdateStubResult is expected values of the Update operation
type ArchiveUpdateStubResult struct {
	Archive *sacloud.Archive
	Err     error
}

// ArchiveDeleteStubResult is expected values of the Delete operation
type ArchiveDeleteStubResult struct {
	Err error
}

// ArchiveOpenFTPStubResult is expected values of the OpenFTP operation
type ArchiveOpenFTPStubResult struct {
	FTPServer *sacloud.FTPServer
	Err       error
}

// ArchiveCloseFTPStubResult is expected values of the CloseFTP operation
type ArchiveCloseFTPStubResult struct {
	Err error
}

// ArchiveShareStubResult is expected values of the Share operation
type ArchiveShareStubResult struct {
	ArchiveShareInfo *sacloud.ArchiveShareInfo
	Err              error
}

// ArchiveCreateFromSharedStubResult is expected values of the CreateFromShared operation
type ArchiveCreateFromSharedStubResult struct {
	Archive *sacloud.Archive
	Err     error
}

// ArchiveTransferStubResult is expected values of the Transfer operation
type ArchiveTransferStubResult struct {
	Archive *sacloud.Archive
	Err     error
}

// ArchiveStub is for trace ArchiveOp operations
type ArchiveStub struct {
	FindStubResult             *ArchiveFindStubResult
	CreateStubResult           *ArchiveCreateStubResult
	CreateBlankStubResult      *ArchiveCreateBlankStubResult
	ReadStubResult             *ArchiveReadStubResult
	UpdateStubResult           *ArchiveUpdateStubResult
	DeleteStubResult           *ArchiveDeleteStubResult
	OpenFTPStubResult          *ArchiveOpenFTPStubResult
	CloseFTPStubResult         *ArchiveCloseFTPStubResult
	ShareStubResult            *ArchiveShareStubResult
	CreateFromSharedStubResult *ArchiveCreateFromSharedStubResult
	TransferStubResult         *ArchiveTransferStubResult
}

// NewArchiveStub creates new ArchiveStub instance
func NewArchiveStub(caller sacloud.APICaller) sacloud.ArchiveAPI {
	return &ArchiveStub{}
}

// Find is API call with trace log
func (s *ArchiveStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.ArchiveFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("ArchiveStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *ArchiveStub) Create(ctx context.Context, zone string, param *sacloud.ArchiveCreateRequest) (*sacloud.Archive, error) {
	if s.CreateStubResult == nil {
		log.Fatal("ArchiveStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.Archive, s.CreateStubResult.Err
}

// CreateBlank is API call with trace log
func (s *ArchiveStub) CreateBlank(ctx context.Context, zone string, param *sacloud.ArchiveCreateBlankRequest) (*sacloud.Archive, *sacloud.FTPServer, error) {
	if s.CreateBlankStubResult == nil {
		log.Fatal("ArchiveStub.CreateBlankStubResult is not set")
	}
	return s.CreateBlankStubResult.Archive, s.CreateBlankStubResult.FTPServer, s.CreateBlankStubResult.Err
}

// Read is API call with trace log
func (s *ArchiveStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Archive, error) {
	if s.ReadStubResult == nil {
		log.Fatal("ArchiveStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Archive, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *ArchiveStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.ArchiveUpdateRequest) (*sacloud.Archive, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("ArchiveStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.Archive, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *ArchiveStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("ArchiveStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// OpenFTP is API call with trace log
func (s *ArchiveStub) OpenFTP(ctx context.Context, zone string, id types.ID, openOption *sacloud.OpenFTPRequest) (*sacloud.FTPServer, error) {
	if s.OpenFTPStubResult == nil {
		log.Fatal("ArchiveStub.OpenFTPStubResult is not set")
	}
	return s.OpenFTPStubResult.FTPServer, s.OpenFTPStubResult.Err
}

// CloseFTP is API call with trace log
func (s *ArchiveStub) CloseFTP(ctx context.Context, zone string, id types.ID) error {
	if s.CloseFTPStubResult == nil {
		log.Fatal("ArchiveStub.CloseFTPStubResult is not set")
	}
	return s.CloseFTPStubResult.Err
}

// Share is API call with trace log
func (s *ArchiveStub) Share(ctx context.Context, zone string, id types.ID) (*sacloud.ArchiveShareInfo, error) {
	if s.ShareStubResult == nil {
		log.Fatal("ArchiveStub.ShareStubResult is not set")
	}
	return s.ShareStubResult.ArchiveShareInfo, s.ShareStubResult.Err
}

// CreateFromShared is API call with trace log
func (s *ArchiveStub) CreateFromShared(ctx context.Context, zone string, sourceArchiveID types.ID, destZoneID types.ID, param *sacloud.ArchiveCreateRequestFromShared) (*sacloud.Archive, error) {
	if s.CreateFromSharedStubResult == nil {
		log.Fatal("ArchiveStub.CreateFromSharedStubResult is not set")
	}
	return s.CreateFromSharedStubResult.Archive, s.CreateFromSharedStubResult.Err
}

// Transfer is API call with trace log
func (s *ArchiveStub) Transfer(ctx context.Context, zone string, sourceArchiveID types.ID, destZoneID types.ID, param *sacloud.ArchiveTransferRequest) (*sacloud.Archive, error) {
	if s.TransferStubResult == nil {
		log.Fatal("ArchiveStub.TransferStubResult is not set")
	}
	return s.TransferStubResult.Archive, s.TransferStubResult.Err
}

/*************************************************
* AuthStatusStub
*************************************************/

// AuthStatusReadStubResult is expected values of the Read operation
type AuthStatusReadStubResult struct {
	AuthStatus *sacloud.AuthStatus
	Err        error
}

// AuthStatusStub is for trace AuthStatusOp operations
type AuthStatusStub struct {
	ReadStubResult *AuthStatusReadStubResult
}

// NewAuthStatusStub creates new AuthStatusStub instance
func NewAuthStatusStub(caller sacloud.APICaller) sacloud.AuthStatusAPI {
	return &AuthStatusStub{}
}

// Read is API call with trace log
func (s *AuthStatusStub) Read(ctx context.Context) (*sacloud.AuthStatus, error) {
	if s.ReadStubResult == nil {
		log.Fatal("AuthStatusStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.AuthStatus, s.ReadStubResult.Err
}

/*************************************************
* AutoBackupStub
*************************************************/

// AutoBackupFindStubResult is expected values of the Find operation
type AutoBackupFindStubResult struct {
	Values *sacloud.AutoBackupFindResult
	Err    error
}

// AutoBackupCreateStubResult is expected values of the Create operation
type AutoBackupCreateStubResult struct {
	AutoBackup *sacloud.AutoBackup
	Err        error
}

// AutoBackupReadStubResult is expected values of the Read operation
type AutoBackupReadStubResult struct {
	AutoBackup *sacloud.AutoBackup
	Err        error
}

// AutoBackupUpdateStubResult is expected values of the Update operation
type AutoBackupUpdateStubResult struct {
	AutoBackup *sacloud.AutoBackup
	Err        error
}

// AutoBackupUpdateSettingsStubResult is expected values of the UpdateSettings operation
type AutoBackupUpdateSettingsStubResult struct {
	AutoBackup *sacloud.AutoBackup
	Err        error
}

// AutoBackupDeleteStubResult is expected values of the Delete operation
type AutoBackupDeleteStubResult struct {
	Err error
}

// AutoBackupStub is for trace AutoBackupOp operations
type AutoBackupStub struct {
	FindStubResult           *AutoBackupFindStubResult
	CreateStubResult         *AutoBackupCreateStubResult
	ReadStubResult           *AutoBackupReadStubResult
	UpdateStubResult         *AutoBackupUpdateStubResult
	UpdateSettingsStubResult *AutoBackupUpdateSettingsStubResult
	DeleteStubResult         *AutoBackupDeleteStubResult
}

// NewAutoBackupStub creates new AutoBackupStub instance
func NewAutoBackupStub(caller sacloud.APICaller) sacloud.AutoBackupAPI {
	return &AutoBackupStub{}
}

// Find is API call with trace log
func (s *AutoBackupStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.AutoBackupFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("AutoBackupStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *AutoBackupStub) Create(ctx context.Context, zone string, param *sacloud.AutoBackupCreateRequest) (*sacloud.AutoBackup, error) {
	if s.CreateStubResult == nil {
		log.Fatal("AutoBackupStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.AutoBackup, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *AutoBackupStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.AutoBackup, error) {
	if s.ReadStubResult == nil {
		log.Fatal("AutoBackupStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.AutoBackup, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *AutoBackupStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.AutoBackupUpdateRequest) (*sacloud.AutoBackup, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("AutoBackupStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.AutoBackup, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *AutoBackupStub) UpdateSettings(ctx context.Context, zone string, id types.ID, param *sacloud.AutoBackupUpdateSettingsRequest) (*sacloud.AutoBackup, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("AutoBackupStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.AutoBackup, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *AutoBackupStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("AutoBackupStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* BillStub
*************************************************/

// BillByContractStubResult is expected values of the ByContract operation
type BillByContractStubResult struct {
	Values *sacloud.BillByContractResult
	Err    error
}

// BillByContractYearStubResult is expected values of the ByContractYear operation
type BillByContractYearStubResult struct {
	Values *sacloud.BillByContractYearResult
	Err    error
}

// BillByContractYearMonthStubResult is expected values of the ByContractYearMonth operation
type BillByContractYearMonthStubResult struct {
	Values *sacloud.BillByContractYearMonthResult
	Err    error
}

// BillReadStubResult is expected values of the Read operation
type BillReadStubResult struct {
	Values *sacloud.BillReadResult
	Err    error
}

// BillDetailsStubResult is expected values of the Details operation
type BillDetailsStubResult struct {
	Values *sacloud.BillDetailsResult
	Err    error
}

// BillDetailsCSVStubResult is expected values of the DetailsCSV operation
type BillDetailsCSVStubResult struct {
	BillDetailCSV *sacloud.BillDetailCSV
	Err           error
}

// BillStub is for trace BillOp operations
type BillStub struct {
	ByContractStubResult          *BillByContractStubResult
	ByContractYearStubResult      *BillByContractYearStubResult
	ByContractYearMonthStubResult *BillByContractYearMonthStubResult
	ReadStubResult                *BillReadStubResult
	DetailsStubResult             *BillDetailsStubResult
	DetailsCSVStubResult          *BillDetailsCSVStubResult
}

// NewBillStub creates new BillStub instance
func NewBillStub(caller sacloud.APICaller) sacloud.BillAPI {
	return &BillStub{}
}

// ByContract is API call with trace log
func (s *BillStub) ByContract(ctx context.Context, accountID types.ID) (*sacloud.BillByContractResult, error) {
	if s.ByContractStubResult == nil {
		log.Fatal("BillStub.ByContractStubResult is not set")
	}
	return s.ByContractStubResult.Values, s.ByContractStubResult.Err
}

// ByContractYear is API call with trace log
func (s *BillStub) ByContractYear(ctx context.Context, accountID types.ID, year int) (*sacloud.BillByContractYearResult, error) {
	if s.ByContractYearStubResult == nil {
		log.Fatal("BillStub.ByContractYearStubResult is not set")
	}
	return s.ByContractYearStubResult.Values, s.ByContractYearStubResult.Err
}

// ByContractYearMonth is API call with trace log
func (s *BillStub) ByContractYearMonth(ctx context.Context, accountID types.ID, year int, month int) (*sacloud.BillByContractYearMonthResult, error) {
	if s.ByContractYearMonthStubResult == nil {
		log.Fatal("BillStub.ByContractYearMonthStubResult is not set")
	}
	return s.ByContractYearMonthStubResult.Values, s.ByContractYearMonthStubResult.Err
}

// Read is API call with trace log
func (s *BillStub) Read(ctx context.Context, id types.ID) (*sacloud.BillReadResult, error) {
	if s.ReadStubResult == nil {
		log.Fatal("BillStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Values, s.ReadStubResult.Err
}

// Details is API call with trace log
func (s *BillStub) Details(ctx context.Context, MemberCode string, id types.ID) (*sacloud.BillDetailsResult, error) {
	if s.DetailsStubResult == nil {
		log.Fatal("BillStub.DetailsStubResult is not set")
	}
	return s.DetailsStubResult.Values, s.DetailsStubResult.Err
}

// DetailsCSV is API call with trace log
func (s *BillStub) DetailsCSV(ctx context.Context, MemberCode string, id types.ID) (*sacloud.BillDetailCSV, error) {
	if s.DetailsCSVStubResult == nil {
		log.Fatal("BillStub.DetailsCSVStubResult is not set")
	}
	return s.DetailsCSVStubResult.BillDetailCSV, s.DetailsCSVStubResult.Err
}

/*************************************************
* BridgeStub
*************************************************/

// BridgeFindStubResult is expected values of the Find operation
type BridgeFindStubResult struct {
	Values *sacloud.BridgeFindResult
	Err    error
}

// BridgeCreateStubResult is expected values of the Create operation
type BridgeCreateStubResult struct {
	Bridge *sacloud.Bridge
	Err    error
}

// BridgeReadStubResult is expected values of the Read operation
type BridgeReadStubResult struct {
	Bridge *sacloud.Bridge
	Err    error
}

// BridgeUpdateStubResult is expected values of the Update operation
type BridgeUpdateStubResult struct {
	Bridge *sacloud.Bridge
	Err    error
}

// BridgeDeleteStubResult is expected values of the Delete operation
type BridgeDeleteStubResult struct {
	Err error
}

// BridgeStub is for trace BridgeOp operations
type BridgeStub struct {
	FindStubResult   *BridgeFindStubResult
	CreateStubResult *BridgeCreateStubResult
	ReadStubResult   *BridgeReadStubResult
	UpdateStubResult *BridgeUpdateStubResult
	DeleteStubResult *BridgeDeleteStubResult
}

// NewBridgeStub creates new BridgeStub instance
func NewBridgeStub(caller sacloud.APICaller) sacloud.BridgeAPI {
	return &BridgeStub{}
}

// Find is API call with trace log
func (s *BridgeStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.BridgeFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("BridgeStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *BridgeStub) Create(ctx context.Context, zone string, param *sacloud.BridgeCreateRequest) (*sacloud.Bridge, error) {
	if s.CreateStubResult == nil {
		log.Fatal("BridgeStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.Bridge, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *BridgeStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Bridge, error) {
	if s.ReadStubResult == nil {
		log.Fatal("BridgeStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Bridge, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *BridgeStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.BridgeUpdateRequest) (*sacloud.Bridge, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("BridgeStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.Bridge, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *BridgeStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("BridgeStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* CDROMStub
*************************************************/

// CDROMFindStubResult is expected values of the Find operation
type CDROMFindStubResult struct {
	Values *sacloud.CDROMFindResult
	Err    error
}

// CDROMCreateStubResult is expected values of the Create operation
type CDROMCreateStubResult struct {
	CDROM     *sacloud.CDROM
	FTPServer *sacloud.FTPServer
	Err       error
}

// CDROMReadStubResult is expected values of the Read operation
type CDROMReadStubResult struct {
	CDROM *sacloud.CDROM
	Err   error
}

// CDROMUpdateStubResult is expected values of the Update operation
type CDROMUpdateStubResult struct {
	CDROM *sacloud.CDROM
	Err   error
}

// CDROMDeleteStubResult is expected values of the Delete operation
type CDROMDeleteStubResult struct {
	Err error
}

// CDROMOpenFTPStubResult is expected values of the OpenFTP operation
type CDROMOpenFTPStubResult struct {
	FTPServer *sacloud.FTPServer
	Err       error
}

// CDROMCloseFTPStubResult is expected values of the CloseFTP operation
type CDROMCloseFTPStubResult struct {
	Err error
}

// CDROMStub is for trace CDROMOp operations
type CDROMStub struct {
	FindStubResult     *CDROMFindStubResult
	CreateStubResult   *CDROMCreateStubResult
	ReadStubResult     *CDROMReadStubResult
	UpdateStubResult   *CDROMUpdateStubResult
	DeleteStubResult   *CDROMDeleteStubResult
	OpenFTPStubResult  *CDROMOpenFTPStubResult
	CloseFTPStubResult *CDROMCloseFTPStubResult
}

// NewCDROMStub creates new CDROMStub instance
func NewCDROMStub(caller sacloud.APICaller) sacloud.CDROMAPI {
	return &CDROMStub{}
}

// Find is API call with trace log
func (s *CDROMStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.CDROMFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("CDROMStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *CDROMStub) Create(ctx context.Context, zone string, param *sacloud.CDROMCreateRequest) (*sacloud.CDROM, *sacloud.FTPServer, error) {
	if s.CreateStubResult == nil {
		log.Fatal("CDROMStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.CDROM, s.CreateStubResult.FTPServer, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *CDROMStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.CDROM, error) {
	if s.ReadStubResult == nil {
		log.Fatal("CDROMStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.CDROM, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *CDROMStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.CDROMUpdateRequest) (*sacloud.CDROM, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("CDROMStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.CDROM, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *CDROMStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("CDROMStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// OpenFTP is API call with trace log
func (s *CDROMStub) OpenFTP(ctx context.Context, zone string, id types.ID, openOption *sacloud.OpenFTPRequest) (*sacloud.FTPServer, error) {
	if s.OpenFTPStubResult == nil {
		log.Fatal("CDROMStub.OpenFTPStubResult is not set")
	}
	return s.OpenFTPStubResult.FTPServer, s.OpenFTPStubResult.Err
}

// CloseFTP is API call with trace log
func (s *CDROMStub) CloseFTP(ctx context.Context, zone string, id types.ID) error {
	if s.CloseFTPStubResult == nil {
		log.Fatal("CDROMStub.CloseFTPStubResult is not set")
	}
	return s.CloseFTPStubResult.Err
}

/*************************************************
* CertificateAuthorityStub
*************************************************/

// CertificateAuthorityFindStubResult is expected values of the Find operation
type CertificateAuthorityFindStubResult struct {
	Values *sacloud.CertificateAuthorityFindResult
	Err    error
}

// CertificateAuthorityCreateStubResult is expected values of the Create operation
type CertificateAuthorityCreateStubResult struct {
	CertificateAuthority *sacloud.CertificateAuthority
	Err                  error
}

// CertificateAuthorityReadStubResult is expected values of the Read operation
type CertificateAuthorityReadStubResult struct {
	CertificateAuthority *sacloud.CertificateAuthority
	Err                  error
}

// CertificateAuthorityUpdateStubResult is expected values of the Update operation
type CertificateAuthorityUpdateStubResult struct {
	CertificateAuthority *sacloud.CertificateAuthority
	Err                  error
}

// CertificateAuthorityDeleteStubResult is expected values of the Delete operation
type CertificateAuthorityDeleteStubResult struct {
	Err error
}

// CertificateAuthorityDetailStubResult is expected values of the Detail operation
type CertificateAuthorityDetailStubResult struct {
	CertificateAuthority *sacloud.CertificateAuthorityDetail
	Err                  error
}

// CertificateAuthorityAddClientStubResult is expected values of the AddClient operation
type CertificateAuthorityAddClientStubResult struct {
	CertificateAuthority *sacloud.CertificateAuthorityAddClientOrServerResult
	Err                  error
}

// CertificateAuthorityListClientsStubResult is expected values of the ListClients operation
type CertificateAuthorityListClientsStubResult struct {
	Values *sacloud.CertificateAuthorityListClientsResult
	Err    error
}

// CertificateAuthorityReadClientStubResult is expected values of the ReadClient operation
type CertificateAuthorityReadClientStubResult struct {
	CertificateAuthority *sacloud.CertificateAuthorityClient
	Err                  error
}

// CertificateAuthorityRevokeClientStubResult is expected values of the RevokeClient operation
type CertificateAuthorityRevokeClientStubResult struct {
	Err error
}

// CertificateAuthorityHoldClientStubResult is expected values of the HoldClient operation
type CertificateAuthorityHoldClientStubResult struct {
	Err error
}

// CertificateAuthorityResumeClientStubResult is expected values of the ResumeClient operation
type CertificateAuthorityResumeClientStubResult struct {
	Err error
}

// CertificateAuthorityDenyClientStubResult is expected values of the DenyClient operation
type CertificateAuthorityDenyClientStubResult struct {
	Err error
}

// CertificateAuthorityAddServerStubResult is expected values of the AddServer operation
type CertificateAuthorityAddServerStubResult struct {
	CertificateAuthority *sacloud.CertificateAuthorityAddClientOrServerResult
	Err                  error
}

// CertificateAuthorityListServersStubResult is expected values of the ListServers operation
type CertificateAuthorityListServersStubResult struct {
	Values *sacloud.CertificateAuthorityListServersResult
	Err    error
}

// CertificateAuthorityReadServerStubResult is expected values of the ReadServer operation
type CertificateAuthorityReadServerStubResult struct {
	CertificateAuthority *sacloud.CertificateAuthorityServer
	Err                  error
}

// CertificateAuthorityRevokeServerStubResult is expected values of the RevokeServer operation
type CertificateAuthorityRevokeServerStubResult struct {
	Err error
}

// CertificateAuthorityHoldServerStubResult is expected values of the HoldServer operation
type CertificateAuthorityHoldServerStubResult struct {
	Err error
}

// CertificateAuthorityResumeServerStubResult is expected values of the ResumeServer operation
type CertificateAuthorityResumeServerStubResult struct {
	Err error
}

// CertificateAuthorityStub is for trace CertificateAuthorityOp operations
type CertificateAuthorityStub struct {
	FindStubResult         *CertificateAuthorityFindStubResult
	CreateStubResult       *CertificateAuthorityCreateStubResult
	ReadStubResult         *CertificateAuthorityReadStubResult
	UpdateStubResult       *CertificateAuthorityUpdateStubResult
	DeleteStubResult       *CertificateAuthorityDeleteStubResult
	DetailStubResult       *CertificateAuthorityDetailStubResult
	AddClientStubResult    *CertificateAuthorityAddClientStubResult
	ListClientsStubResult  *CertificateAuthorityListClientsStubResult
	ReadClientStubResult   *CertificateAuthorityReadClientStubResult
	RevokeClientStubResult *CertificateAuthorityRevokeClientStubResult
	HoldClientStubResult   *CertificateAuthorityHoldClientStubResult
	ResumeClientStubResult *CertificateAuthorityResumeClientStubResult
	DenyClientStubResult   *CertificateAuthorityDenyClientStubResult
	AddServerStubResult    *CertificateAuthorityAddServerStubResult
	ListServersStubResult  *CertificateAuthorityListServersStubResult
	ReadServerStubResult   *CertificateAuthorityReadServerStubResult
	RevokeServerStubResult *CertificateAuthorityRevokeServerStubResult
	HoldServerStubResult   *CertificateAuthorityHoldServerStubResult
	ResumeServerStubResult *CertificateAuthorityResumeServerStubResult
}

// NewCertificateAuthorityStub creates new CertificateAuthorityStub instance
func NewCertificateAuthorityStub(caller sacloud.APICaller) sacloud.CertificateAuthorityAPI {
	return &CertificateAuthorityStub{}
}

// Find is API call with trace log
func (s *CertificateAuthorityStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.CertificateAuthorityFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("CertificateAuthorityStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *CertificateAuthorityStub) Create(ctx context.Context, param *sacloud.CertificateAuthorityCreateRequest) (*sacloud.CertificateAuthority, error) {
	if s.CreateStubResult == nil {
		log.Fatal("CertificateAuthorityStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.CertificateAuthority, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *CertificateAuthorityStub) Read(ctx context.Context, id types.ID) (*sacloud.CertificateAuthority, error) {
	if s.ReadStubResult == nil {
		log.Fatal("CertificateAuthorityStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.CertificateAuthority, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *CertificateAuthorityStub) Update(ctx context.Context, id types.ID, param *sacloud.CertificateAuthorityUpdateRequest) (*sacloud.CertificateAuthority, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("CertificateAuthorityStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.CertificateAuthority, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *CertificateAuthorityStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("CertificateAuthorityStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// Detail is API call with trace log
func (s *CertificateAuthorityStub) Detail(ctx context.Context, id types.ID) (*sacloud.CertificateAuthorityDetail, error) {
	if s.DetailStubResult == nil {
		log.Fatal("CertificateAuthorityStub.DetailStubResult is not set")
	}
	return s.DetailStubResult.CertificateAuthority, s.DetailStubResult.Err
}

// AddClient is API call with trace log
func (s *CertificateAuthorityStub) AddClient(ctx context.Context, id types.ID, param *sacloud.CertificateAuthorityAddClientParam) (*sacloud.CertificateAuthorityAddClientOrServerResult, error) {
	if s.AddClientStubResult == nil {
		log.Fatal("CertificateAuthorityStub.AddClientStubResult is not set")
	}
	return s.AddClientStubResult.CertificateAuthority, s.AddClientStubResult.Err
}

// ListClients is API call with trace log
func (s *CertificateAuthorityStub) ListClients(ctx context.Context, id types.ID) (*sacloud.CertificateAuthorityListClientsResult, error) {
	if s.ListClientsStubResult == nil {
		log.Fatal("CertificateAuthorityStub.ListClientsStubResult is not set")
	}
	return s.ListClientsStubResult.Values, s.ListClientsStubResult.Err
}

// ReadClient is API call with trace log
func (s *CertificateAuthorityStub) ReadClient(ctx context.Context, id types.ID, clientID string) (*sacloud.CertificateAuthorityClient, error) {
	if s.ReadClientStubResult == nil {
		log.Fatal("CertificateAuthorityStub.ReadClientStubResult is not set")
	}
	return s.ReadClientStubResult.CertificateAuthority, s.ReadClientStubResult.Err
}

// RevokeClient is API call with trace log
func (s *CertificateAuthorityStub) RevokeClient(ctx context.Context, id types.ID, clientID string) error {
	if s.RevokeClientStubResult == nil {
		log.Fatal("CertificateAuthorityStub.RevokeClientStubResult is not set")
	}
	return s.RevokeClientStubResult.Err
}

// HoldClient is API call with trace log
func (s *CertificateAuthorityStub) HoldClient(ctx context.Context, id types.ID, clientID string) error {
	if s.HoldClientStubResult == nil {
		log.Fatal("CertificateAuthorityStub.HoldClientStubResult is not set")
	}
	return s.HoldClientStubResult.Err
}

// ResumeClient is API call with trace log
func (s *CertificateAuthorityStub) ResumeClient(ctx context.Context, id types.ID, clientID string) error {
	if s.ResumeClientStubResult == nil {
		log.Fatal("CertificateAuthorityStub.ResumeClientStubResult is not set")
	}
	return s.ResumeClientStubResult.Err
}

// DenyClient is API call with trace log
func (s *CertificateAuthorityStub) DenyClient(ctx context.Context, id types.ID, clientID string) error {
	if s.DenyClientStubResult == nil {
		log.Fatal("CertificateAuthorityStub.DenyClientStubResult is not set")
	}
	return s.DenyClientStubResult.Err
}

// AddServer is API call with trace log
func (s *CertificateAuthorityStub) AddServer(ctx context.Context, id types.ID, param *sacloud.CertificateAuthorityAddServerParam) (*sacloud.CertificateAuthorityAddClientOrServerResult, error) {
	if s.AddServerStubResult == nil {
		log.Fatal("CertificateAuthorityStub.AddServerStubResult is not set")
	}
	return s.AddServerStubResult.CertificateAuthority, s.AddServerStubResult.Err
}

// ListServers is API call with trace log
func (s *CertificateAuthorityStub) ListServers(ctx context.Context, id types.ID) (*sacloud.CertificateAuthorityListServersResult, error) {
	if s.ListServersStubResult == nil {
		log.Fatal("CertificateAuthorityStub.ListServersStubResult is not set")
	}
	return s.ListServersStubResult.Values, s.ListServersStubResult.Err
}

// ReadServer is API call with trace log
func (s *CertificateAuthorityStub) ReadServer(ctx context.Context, id types.ID, serverID string) (*sacloud.CertificateAuthorityServer, error) {
	if s.ReadServerStubResult == nil {
		log.Fatal("CertificateAuthorityStub.ReadServerStubResult is not set")
	}
	return s.ReadServerStubResult.CertificateAuthority, s.ReadServerStubResult.Err
}

// RevokeServer is API call with trace log
func (s *CertificateAuthorityStub) RevokeServer(ctx context.Context, id types.ID, serverID string) error {
	if s.RevokeServerStubResult == nil {
		log.Fatal("CertificateAuthorityStub.RevokeServerStubResult is not set")
	}
	return s.RevokeServerStubResult.Err
}

// HoldServer is API call with trace log
func (s *CertificateAuthorityStub) HoldServer(ctx context.Context, id types.ID, serverID string) error {
	if s.HoldServerStubResult == nil {
		log.Fatal("CertificateAuthorityStub.HoldServerStubResult is not set")
	}
	return s.HoldServerStubResult.Err
}

// ResumeServer is API call with trace log
func (s *CertificateAuthorityStub) ResumeServer(ctx context.Context, id types.ID, serverID string) error {
	if s.ResumeServerStubResult == nil {
		log.Fatal("CertificateAuthorityStub.ResumeServerStubResult is not set")
	}
	return s.ResumeServerStubResult.Err
}

/*************************************************
* ContainerRegistryStub
*************************************************/

// ContainerRegistryFindStubResult is expected values of the Find operation
type ContainerRegistryFindStubResult struct {
	Values *sacloud.ContainerRegistryFindResult
	Err    error
}

// ContainerRegistryCreateStubResult is expected values of the Create operation
type ContainerRegistryCreateStubResult struct {
	ContainerRegistry *sacloud.ContainerRegistry
	Err               error
}

// ContainerRegistryReadStubResult is expected values of the Read operation
type ContainerRegistryReadStubResult struct {
	ContainerRegistry *sacloud.ContainerRegistry
	Err               error
}

// ContainerRegistryUpdateStubResult is expected values of the Update operation
type ContainerRegistryUpdateStubResult struct {
	ContainerRegistry *sacloud.ContainerRegistry
	Err               error
}

// ContainerRegistryUpdateSettingsStubResult is expected values of the UpdateSettings operation
type ContainerRegistryUpdateSettingsStubResult struct {
	ContainerRegistry *sacloud.ContainerRegistry
	Err               error
}

// ContainerRegistryDeleteStubResult is expected values of the Delete operation
type ContainerRegistryDeleteStubResult struct {
	Err error
}

// ContainerRegistryListUsersStubResult is expected values of the ListUsers operation
type ContainerRegistryListUsersStubResult struct {
	ContainerRegistryUsers *sacloud.ContainerRegistryUsers
	Err                    error
}

// ContainerRegistryAddUserStubResult is expected values of the AddUser operation
type ContainerRegistryAddUserStubResult struct {
	Err error
}

// ContainerRegistryUpdateUserStubResult is expected values of the UpdateUser operation
type ContainerRegistryUpdateUserStubResult struct {
	Err error
}

// ContainerRegistryDeleteUserStubResult is expected values of the DeleteUser operation
type ContainerRegistryDeleteUserStubResult struct {
	Err error
}

// ContainerRegistryStub is for trace ContainerRegistryOp operations
type ContainerRegistryStub struct {
	FindStubResult           *ContainerRegistryFindStubResult
	CreateStubResult         *ContainerRegistryCreateStubResult
	ReadStubResult           *ContainerRegistryReadStubResult
	UpdateStubResult         *ContainerRegistryUpdateStubResult
	UpdateSettingsStubResult *ContainerRegistryUpdateSettingsStubResult
	DeleteStubResult         *ContainerRegistryDeleteStubResult
	ListUsersStubResult      *ContainerRegistryListUsersStubResult
	AddUserStubResult        *ContainerRegistryAddUserStubResult
	UpdateUserStubResult     *ContainerRegistryUpdateUserStubResult
	DeleteUserStubResult     *ContainerRegistryDeleteUserStubResult
}

// NewContainerRegistryStub creates new ContainerRegistryStub instance
func NewContainerRegistryStub(caller sacloud.APICaller) sacloud.ContainerRegistryAPI {
	return &ContainerRegistryStub{}
}

// Find is API call with trace log
func (s *ContainerRegistryStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.ContainerRegistryFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("ContainerRegistryStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *ContainerRegistryStub) Create(ctx context.Context, param *sacloud.ContainerRegistryCreateRequest) (*sacloud.ContainerRegistry, error) {
	if s.CreateStubResult == nil {
		log.Fatal("ContainerRegistryStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.ContainerRegistry, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *ContainerRegistryStub) Read(ctx context.Context, id types.ID) (*sacloud.ContainerRegistry, error) {
	if s.ReadStubResult == nil {
		log.Fatal("ContainerRegistryStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.ContainerRegistry, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *ContainerRegistryStub) Update(ctx context.Context, id types.ID, param *sacloud.ContainerRegistryUpdateRequest) (*sacloud.ContainerRegistry, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("ContainerRegistryStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.ContainerRegistry, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *ContainerRegistryStub) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.ContainerRegistryUpdateSettingsRequest) (*sacloud.ContainerRegistry, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("ContainerRegistryStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.ContainerRegistry, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *ContainerRegistryStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("ContainerRegistryStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// ListUsers is API call with trace log
func (s *ContainerRegistryStub) ListUsers(ctx context.Context, id types.ID) (*sacloud.ContainerRegistryUsers, error) {
	if s.ListUsersStubResult == nil {
		log.Fatal("ContainerRegistryStub.ListUsersStubResult is not set")
	}
	return s.ListUsersStubResult.ContainerRegistryUsers, s.ListUsersStubResult.Err
}

// AddUser is API call with trace log
func (s *ContainerRegistryStub) AddUser(ctx context.Context, id types.ID, param *sacloud.ContainerRegistryUserCreateRequest) error {
	if s.AddUserStubResult == nil {
		log.Fatal("ContainerRegistryStub.AddUserStubResult is not set")
	}
	return s.AddUserStubResult.Err
}

// UpdateUser is API call with trace log
func (s *ContainerRegistryStub) UpdateUser(ctx context.Context, id types.ID, username string, param *sacloud.ContainerRegistryUserUpdateRequest) error {
	if s.UpdateUserStubResult == nil {
		log.Fatal("ContainerRegistryStub.UpdateUserStubResult is not set")
	}
	return s.UpdateUserStubResult.Err
}

// DeleteUser is API call with trace log
func (s *ContainerRegistryStub) DeleteUser(ctx context.Context, id types.ID, username string) error {
	if s.DeleteUserStubResult == nil {
		log.Fatal("ContainerRegistryStub.DeleteUserStubResult is not set")
	}
	return s.DeleteUserStubResult.Err
}

/*************************************************
* CouponStub
*************************************************/

// CouponFindStubResult is expected values of the Find operation
type CouponFindStubResult struct {
	Values *sacloud.CouponFindResult
	Err    error
}

// CouponStub is for trace CouponOp operations
type CouponStub struct {
	FindStubResult *CouponFindStubResult
}

// NewCouponStub creates new CouponStub instance
func NewCouponStub(caller sacloud.APICaller) sacloud.CouponAPI {
	return &CouponStub{}
}

// Find is API call with trace log
func (s *CouponStub) Find(ctx context.Context, accountID types.ID) (*sacloud.CouponFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("CouponStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

/*************************************************
* DatabaseStub
*************************************************/

// DatabaseFindStubResult is expected values of the Find operation
type DatabaseFindStubResult struct {
	Values *sacloud.DatabaseFindResult
	Err    error
}

// DatabaseCreateStubResult is expected values of the Create operation
type DatabaseCreateStubResult struct {
	Database *sacloud.Database
	Err      error
}

// DatabaseReadStubResult is expected values of the Read operation
type DatabaseReadStubResult struct {
	Database *sacloud.Database
	Err      error
}

// DatabaseUpdateStubResult is expected values of the Update operation
type DatabaseUpdateStubResult struct {
	Database *sacloud.Database
	Err      error
}

// DatabaseUpdateSettingsStubResult is expected values of the UpdateSettings operation
type DatabaseUpdateSettingsStubResult struct {
	Database *sacloud.Database
	Err      error
}

// DatabaseDeleteStubResult is expected values of the Delete operation
type DatabaseDeleteStubResult struct {
	Err error
}

// DatabaseConfigStubResult is expected values of the Config operation
type DatabaseConfigStubResult struct {
	Err error
}

// DatabaseBootStubResult is expected values of the Boot operation
type DatabaseBootStubResult struct {
	Err error
}

// DatabaseShutdownStubResult is expected values of the Shutdown operation
type DatabaseShutdownStubResult struct {
	Err error
}

// DatabaseResetStubResult is expected values of the Reset operation
type DatabaseResetStubResult struct {
	Err error
}

// DatabaseMonitorCPUStubResult is expected values of the MonitorCPU operation
type DatabaseMonitorCPUStubResult struct {
	CPUTimeActivity *sacloud.CPUTimeActivity
	Err             error
}

// DatabaseMonitorDiskStubResult is expected values of the MonitorDisk operation
type DatabaseMonitorDiskStubResult struct {
	DiskActivity *sacloud.DiskActivity
	Err          error
}

// DatabaseMonitorInterfaceStubResult is expected values of the MonitorInterface operation
type DatabaseMonitorInterfaceStubResult struct {
	InterfaceActivity *sacloud.InterfaceActivity
	Err               error
}

// DatabaseMonitorDatabaseStubResult is expected values of the MonitorDatabase operation
type DatabaseMonitorDatabaseStubResult struct {
	DatabaseActivity *sacloud.DatabaseActivity
	Err              error
}

// DatabaseStatusStubResult is expected values of the Status operation
type DatabaseStatusStubResult struct {
	DatabaseStatus *sacloud.DatabaseStatus
	Err            error
}

// DatabaseGetParameterStubResult is expected values of the GetParameter operation
type DatabaseGetParameterStubResult struct {
	DatabaseParameter *sacloud.DatabaseParameter
	Err               error
}

// DatabaseSetParameterStubResult is expected values of the SetParameter operation
type DatabaseSetParameterStubResult struct {
	Err error
}

// DatabaseStub is for trace DatabaseOp operations
type DatabaseStub struct {
	FindStubResult             *DatabaseFindStubResult
	CreateStubResult           *DatabaseCreateStubResult
	ReadStubResult             *DatabaseReadStubResult
	UpdateStubResult           *DatabaseUpdateStubResult
	UpdateSettingsStubResult   *DatabaseUpdateSettingsStubResult
	DeleteStubResult           *DatabaseDeleteStubResult
	ConfigStubResult           *DatabaseConfigStubResult
	BootStubResult             *DatabaseBootStubResult
	ShutdownStubResult         *DatabaseShutdownStubResult
	ResetStubResult            *DatabaseResetStubResult
	MonitorCPUStubResult       *DatabaseMonitorCPUStubResult
	MonitorDiskStubResult      *DatabaseMonitorDiskStubResult
	MonitorInterfaceStubResult *DatabaseMonitorInterfaceStubResult
	MonitorDatabaseStubResult  *DatabaseMonitorDatabaseStubResult
	StatusStubResult           *DatabaseStatusStubResult
	GetParameterStubResult     *DatabaseGetParameterStubResult
	SetParameterStubResult     *DatabaseSetParameterStubResult
}

// NewDatabaseStub creates new DatabaseStub instance
func NewDatabaseStub(caller sacloud.APICaller) sacloud.DatabaseAPI {
	return &DatabaseStub{}
}

// Find is API call with trace log
func (s *DatabaseStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.DatabaseFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("DatabaseStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *DatabaseStub) Create(ctx context.Context, zone string, param *sacloud.DatabaseCreateRequest) (*sacloud.Database, error) {
	if s.CreateStubResult == nil {
		log.Fatal("DatabaseStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.Database, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *DatabaseStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Database, error) {
	if s.ReadStubResult == nil {
		log.Fatal("DatabaseStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Database, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *DatabaseStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.DatabaseUpdateRequest) (*sacloud.Database, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("DatabaseStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.Database, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *DatabaseStub) UpdateSettings(ctx context.Context, zone string, id types.ID, param *sacloud.DatabaseUpdateSettingsRequest) (*sacloud.Database, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("DatabaseStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.Database, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *DatabaseStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("DatabaseStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// Config is API call with trace log
func (s *DatabaseStub) Config(ctx context.Context, zone string, id types.ID) error {
	if s.ConfigStubResult == nil {
		log.Fatal("DatabaseStub.ConfigStubResult is not set")
	}
	return s.ConfigStubResult.Err
}

// Boot is API call with trace log
func (s *DatabaseStub) Boot(ctx context.Context, zone string, id types.ID) error {
	if s.BootStubResult == nil {
		log.Fatal("DatabaseStub.BootStubResult is not set")
	}
	return s.BootStubResult.Err
}

// Shutdown is API call with trace log
func (s *DatabaseStub) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	if s.ShutdownStubResult == nil {
		log.Fatal("DatabaseStub.ShutdownStubResult is not set")
	}
	return s.ShutdownStubResult.Err
}

// Reset is API call with trace log
func (s *DatabaseStub) Reset(ctx context.Context, zone string, id types.ID) error {
	if s.ResetStubResult == nil {
		log.Fatal("DatabaseStub.ResetStubResult is not set")
	}
	return s.ResetStubResult.Err
}

// MonitorCPU is API call with trace log
func (s *DatabaseStub) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	if s.MonitorCPUStubResult == nil {
		log.Fatal("DatabaseStub.MonitorCPUStubResult is not set")
	}
	return s.MonitorCPUStubResult.CPUTimeActivity, s.MonitorCPUStubResult.Err
}

// MonitorDisk is API call with trace log
func (s *DatabaseStub) MonitorDisk(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.DiskActivity, error) {
	if s.MonitorDiskStubResult == nil {
		log.Fatal("DatabaseStub.MonitorDiskStubResult is not set")
	}
	return s.MonitorDiskStubResult.DiskActivity, s.MonitorDiskStubResult.Err
}

// MonitorInterface is API call with trace log
func (s *DatabaseStub) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	if s.MonitorInterfaceStubResult == nil {
		log.Fatal("DatabaseStub.MonitorInterfaceStubResult is not set")
	}
	return s.MonitorInterfaceStubResult.InterfaceActivity, s.MonitorInterfaceStubResult.Err
}

// MonitorDatabase is API call with trace log
func (s *DatabaseStub) MonitorDatabase(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.DatabaseActivity, error) {
	if s.MonitorDatabaseStubResult == nil {
		log.Fatal("DatabaseStub.MonitorDatabaseStubResult is not set")
	}
	return s.MonitorDatabaseStubResult.DatabaseActivity, s.MonitorDatabaseStubResult.Err
}

// Status is API call with trace log
func (s *DatabaseStub) Status(ctx context.Context, zone string, id types.ID) (*sacloud.DatabaseStatus, error) {
	if s.StatusStubResult == nil {
		log.Fatal("DatabaseStub.StatusStubResult is not set")
	}
	return s.StatusStubResult.DatabaseStatus, s.StatusStubResult.Err
}

// GetParameter is API call with trace log
func (s *DatabaseStub) GetParameter(ctx context.Context, zone string, id types.ID) (*sacloud.DatabaseParameter, error) {
	if s.GetParameterStubResult == nil {
		log.Fatal("DatabaseStub.GetParameterStubResult is not set")
	}
	return s.GetParameterStubResult.DatabaseParameter, s.GetParameterStubResult.Err
}

// SetParameter is API call with trace log
func (s *DatabaseStub) SetParameter(ctx context.Context, zone string, id types.ID, param map[string]interface{}) error {
	if s.SetParameterStubResult == nil {
		log.Fatal("DatabaseStub.SetParameterStubResult is not set")
	}
	return s.SetParameterStubResult.Err
}

/*************************************************
* DiskStub
*************************************************/

// DiskFindStubResult is expected values of the Find operation
type DiskFindStubResult struct {
	Values *sacloud.DiskFindResult
	Err    error
}

// DiskCreateStubResult is expected values of the Create operation
type DiskCreateStubResult struct {
	Disk *sacloud.Disk
	Err  error
}

// DiskConfigStubResult is expected values of the Config operation
type DiskConfigStubResult struct {
	Err error
}

// DiskCreateWithConfigStubResult is expected values of the CreateWithConfig operation
type DiskCreateWithConfigStubResult struct {
	Disk *sacloud.Disk
	Err  error
}

// DiskResizePartitionStubResult is expected values of the ResizePartition operation
type DiskResizePartitionStubResult struct {
	Err error
}

// DiskConnectToServerStubResult is expected values of the ConnectToServer operation
type DiskConnectToServerStubResult struct {
	Err error
}

// DiskDisconnectFromServerStubResult is expected values of the DisconnectFromServer operation
type DiskDisconnectFromServerStubResult struct {
	Err error
}

// DiskReadStubResult is expected values of the Read operation
type DiskReadStubResult struct {
	Disk *sacloud.Disk
	Err  error
}

// DiskUpdateStubResult is expected values of the Update operation
type DiskUpdateStubResult struct {
	Disk *sacloud.Disk
	Err  error
}

// DiskDeleteStubResult is expected values of the Delete operation
type DiskDeleteStubResult struct {
	Err error
}

// DiskMonitorStubResult is expected values of the Monitor operation
type DiskMonitorStubResult struct {
	DiskActivity *sacloud.DiskActivity
	Err          error
}

// DiskMonitorDiskStubResult is expected values of the MonitorDisk operation
type DiskMonitorDiskStubResult struct {
	DiskActivity *sacloud.DiskActivity
	Err          error
}

// DiskStub is for trace DiskOp operations
type DiskStub struct {
	FindStubResult                 *DiskFindStubResult
	CreateStubResult               *DiskCreateStubResult
	ConfigStubResult               *DiskConfigStubResult
	CreateWithConfigStubResult     *DiskCreateWithConfigStubResult
	ResizePartitionStubResult      *DiskResizePartitionStubResult
	ConnectToServerStubResult      *DiskConnectToServerStubResult
	DisconnectFromServerStubResult *DiskDisconnectFromServerStubResult
	ReadStubResult                 *DiskReadStubResult
	UpdateStubResult               *DiskUpdateStubResult
	DeleteStubResult               *DiskDeleteStubResult
	MonitorStubResult              *DiskMonitorStubResult
	MonitorDiskStubResult          *DiskMonitorDiskStubResult
}

// NewDiskStub creates new DiskStub instance
func NewDiskStub(caller sacloud.APICaller) sacloud.DiskAPI {
	return &DiskStub{}
}

// Find is API call with trace log
func (s *DiskStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.DiskFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("DiskStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *DiskStub) Create(ctx context.Context, zone string, createParam *sacloud.DiskCreateRequest, distantFrom []types.ID) (*sacloud.Disk, error) {
	if s.CreateStubResult == nil {
		log.Fatal("DiskStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.Disk, s.CreateStubResult.Err
}

// Config is API call with trace log
func (s *DiskStub) Config(ctx context.Context, zone string, id types.ID, edit *sacloud.DiskEditRequest) error {
	if s.ConfigStubResult == nil {
		log.Fatal("DiskStub.ConfigStubResult is not set")
	}
	return s.ConfigStubResult.Err
}

// CreateWithConfig is API call with trace log
func (s *DiskStub) CreateWithConfig(ctx context.Context, zone string, createParam *sacloud.DiskCreateRequest, editParam *sacloud.DiskEditRequest, bootAtAvailable bool, distantFrom []types.ID) (*sacloud.Disk, error) {
	if s.CreateWithConfigStubResult == nil {
		log.Fatal("DiskStub.CreateWithConfigStubResult is not set")
	}
	return s.CreateWithConfigStubResult.Disk, s.CreateWithConfigStubResult.Err
}

// ResizePartition is API call with trace log
func (s *DiskStub) ResizePartition(ctx context.Context, zone string, id types.ID, param *sacloud.DiskResizePartitionRequest) error {
	if s.ResizePartitionStubResult == nil {
		log.Fatal("DiskStub.ResizePartitionStubResult is not set")
	}
	return s.ResizePartitionStubResult.Err
}

// ConnectToServer is API call with trace log
func (s *DiskStub) ConnectToServer(ctx context.Context, zone string, id types.ID, serverID types.ID) error {
	if s.ConnectToServerStubResult == nil {
		log.Fatal("DiskStub.ConnectToServerStubResult is not set")
	}
	return s.ConnectToServerStubResult.Err
}

// DisconnectFromServer is API call with trace log
func (s *DiskStub) DisconnectFromServer(ctx context.Context, zone string, id types.ID) error {
	if s.DisconnectFromServerStubResult == nil {
		log.Fatal("DiskStub.DisconnectFromServerStubResult is not set")
	}
	return s.DisconnectFromServerStubResult.Err
}

// Read is API call with trace log
func (s *DiskStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Disk, error) {
	if s.ReadStubResult == nil {
		log.Fatal("DiskStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Disk, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *DiskStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.DiskUpdateRequest) (*sacloud.Disk, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("DiskStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.Disk, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *DiskStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("DiskStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// Monitor is API call with trace log
func (s *DiskStub) Monitor(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.DiskActivity, error) {
	if s.MonitorStubResult == nil {
		log.Fatal("DiskStub.MonitorStubResult is not set")
	}
	return s.MonitorStubResult.DiskActivity, s.MonitorStubResult.Err
}

// MonitorDisk is API call with trace log
func (s *DiskStub) MonitorDisk(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.DiskActivity, error) {
	if s.MonitorDiskStubResult == nil {
		log.Fatal("DiskStub.MonitorDiskStubResult is not set")
	}
	return s.MonitorDiskStubResult.DiskActivity, s.MonitorDiskStubResult.Err
}

/*************************************************
* DiskPlanStub
*************************************************/

// DiskPlanFindStubResult is expected values of the Find operation
type DiskPlanFindStubResult struct {
	Values *sacloud.DiskPlanFindResult
	Err    error
}

// DiskPlanReadStubResult is expected values of the Read operation
type DiskPlanReadStubResult struct {
	DiskPlan *sacloud.DiskPlan
	Err      error
}

// DiskPlanStub is for trace DiskPlanOp operations
type DiskPlanStub struct {
	FindStubResult *DiskPlanFindStubResult
	ReadStubResult *DiskPlanReadStubResult
}

// NewDiskPlanStub creates new DiskPlanStub instance
func NewDiskPlanStub(caller sacloud.APICaller) sacloud.DiskPlanAPI {
	return &DiskPlanStub{}
}

// Find is API call with trace log
func (s *DiskPlanStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.DiskPlanFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("DiskPlanStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Read is API call with trace log
func (s *DiskPlanStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.DiskPlan, error) {
	if s.ReadStubResult == nil {
		log.Fatal("DiskPlanStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.DiskPlan, s.ReadStubResult.Err
}

/*************************************************
* DNSStub
*************************************************/

// DNSFindStubResult is expected values of the Find operation
type DNSFindStubResult struct {
	Values *sacloud.DNSFindResult
	Err    error
}

// DNSCreateStubResult is expected values of the Create operation
type DNSCreateStubResult struct {
	DNS *sacloud.DNS
	Err error
}

// DNSReadStubResult is expected values of the Read operation
type DNSReadStubResult struct {
	DNS *sacloud.DNS
	Err error
}

// DNSUpdateStubResult is expected values of the Update operation
type DNSUpdateStubResult struct {
	DNS *sacloud.DNS
	Err error
}

// DNSUpdateSettingsStubResult is expected values of the UpdateSettings operation
type DNSUpdateSettingsStubResult struct {
	DNS *sacloud.DNS
	Err error
}

// DNSDeleteStubResult is expected values of the Delete operation
type DNSDeleteStubResult struct {
	Err error
}

// DNSStub is for trace DNSOp operations
type DNSStub struct {
	FindStubResult           *DNSFindStubResult
	CreateStubResult         *DNSCreateStubResult
	ReadStubResult           *DNSReadStubResult
	UpdateStubResult         *DNSUpdateStubResult
	UpdateSettingsStubResult *DNSUpdateSettingsStubResult
	DeleteStubResult         *DNSDeleteStubResult
}

// NewDNSStub creates new DNSStub instance
func NewDNSStub(caller sacloud.APICaller) sacloud.DNSAPI {
	return &DNSStub{}
}

// Find is API call with trace log
func (s *DNSStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.DNSFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("DNSStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *DNSStub) Create(ctx context.Context, param *sacloud.DNSCreateRequest) (*sacloud.DNS, error) {
	if s.CreateStubResult == nil {
		log.Fatal("DNSStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.DNS, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *DNSStub) Read(ctx context.Context, id types.ID) (*sacloud.DNS, error) {
	if s.ReadStubResult == nil {
		log.Fatal("DNSStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.DNS, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *DNSStub) Update(ctx context.Context, id types.ID, param *sacloud.DNSUpdateRequest) (*sacloud.DNS, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("DNSStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.DNS, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *DNSStub) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.DNSUpdateSettingsRequest) (*sacloud.DNS, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("DNSStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.DNS, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *DNSStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("DNSStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* EnhancedDBStub
*************************************************/

// EnhancedDBFindStubResult is expected values of the Find operation
type EnhancedDBFindStubResult struct {
	Values *sacloud.EnhancedDBFindResult
	Err    error
}

// EnhancedDBCreateStubResult is expected values of the Create operation
type EnhancedDBCreateStubResult struct {
	EnhancedDB *sacloud.EnhancedDB
	Err        error
}

// EnhancedDBReadStubResult is expected values of the Read operation
type EnhancedDBReadStubResult struct {
	EnhancedDB *sacloud.EnhancedDB
	Err        error
}

// EnhancedDBUpdateStubResult is expected values of the Update operation
type EnhancedDBUpdateStubResult struct {
	EnhancedDB *sacloud.EnhancedDB
	Err        error
}

// EnhancedDBDeleteStubResult is expected values of the Delete operation
type EnhancedDBDeleteStubResult struct {
	Err error
}

// EnhancedDBSetPasswordStubResult is expected values of the SetPassword operation
type EnhancedDBSetPasswordStubResult struct {
	Err error
}

// EnhancedDBStub is for trace EnhancedDBOp operations
type EnhancedDBStub struct {
	FindStubResult        *EnhancedDBFindStubResult
	CreateStubResult      *EnhancedDBCreateStubResult
	ReadStubResult        *EnhancedDBReadStubResult
	UpdateStubResult      *EnhancedDBUpdateStubResult
	DeleteStubResult      *EnhancedDBDeleteStubResult
	SetPasswordStubResult *EnhancedDBSetPasswordStubResult
}

// NewEnhancedDBStub creates new EnhancedDBStub instance
func NewEnhancedDBStub(caller sacloud.APICaller) sacloud.EnhancedDBAPI {
	return &EnhancedDBStub{}
}

// Find is API call with trace log
func (s *EnhancedDBStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.EnhancedDBFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("EnhancedDBStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *EnhancedDBStub) Create(ctx context.Context, param *sacloud.EnhancedDBCreateRequest) (*sacloud.EnhancedDB, error) {
	if s.CreateStubResult == nil {
		log.Fatal("EnhancedDBStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.EnhancedDB, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *EnhancedDBStub) Read(ctx context.Context, id types.ID) (*sacloud.EnhancedDB, error) {
	if s.ReadStubResult == nil {
		log.Fatal("EnhancedDBStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.EnhancedDB, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *EnhancedDBStub) Update(ctx context.Context, id types.ID, param *sacloud.EnhancedDBUpdateRequest) (*sacloud.EnhancedDB, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("EnhancedDBStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.EnhancedDB, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *EnhancedDBStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("EnhancedDBStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// SetPassword is API call with trace log
func (s *EnhancedDBStub) SetPassword(ctx context.Context, id types.ID, param *sacloud.EnhancedDBSetPasswordRequest) error {
	if s.SetPasswordStubResult == nil {
		log.Fatal("EnhancedDBStub.SetPasswordStubResult is not set")
	}
	return s.SetPasswordStubResult.Err
}

/*************************************************
* ESMEStub
*************************************************/

// ESMEFindStubResult is expected values of the Find operation
type ESMEFindStubResult struct {
	Values *sacloud.ESMEFindResult
	Err    error
}

// ESMECreateStubResult is expected values of the Create operation
type ESMECreateStubResult struct {
	ESME *sacloud.ESME
	Err  error
}

// ESMEReadStubResult is expected values of the Read operation
type ESMEReadStubResult struct {
	ESME *sacloud.ESME
	Err  error
}

// ESMEUpdateStubResult is expected values of the Update operation
type ESMEUpdateStubResult struct {
	ESME *sacloud.ESME
	Err  error
}

// ESMEDeleteStubResult is expected values of the Delete operation
type ESMEDeleteStubResult struct {
	Err error
}

// ESMESendMessageWithGeneratedOTPStubResult is expected values of the SendMessageWithGeneratedOTP operation
type ESMESendMessageWithGeneratedOTPStubResult struct {
	ESMESendMessageResult *sacloud.ESMESendMessageResult
	Err                   error
}

// ESMESendMessageWithInputtedOTPStubResult is expected values of the SendMessageWithInputtedOTP operation
type ESMESendMessageWithInputtedOTPStubResult struct {
	ESMESendMessageResult *sacloud.ESMESendMessageResult
	Err                   error
}

// ESMELogsStubResult is expected values of the Logs operation
type ESMELogsStubResult struct {
	Logs []*sacloud.ESMELogs
	Err  error
}

// ESMEStub is for trace ESMEOp operations
type ESMEStub struct {
	FindStubResult                        *ESMEFindStubResult
	CreateStubResult                      *ESMECreateStubResult
	ReadStubResult                        *ESMEReadStubResult
	UpdateStubResult                      *ESMEUpdateStubResult
	DeleteStubResult                      *ESMEDeleteStubResult
	SendMessageWithGeneratedOTPStubResult *ESMESendMessageWithGeneratedOTPStubResult
	SendMessageWithInputtedOTPStubResult  *ESMESendMessageWithInputtedOTPStubResult
	LogsStubResult                        *ESMELogsStubResult
}

// NewESMEStub creates new ESMEStub instance
func NewESMEStub(caller sacloud.APICaller) sacloud.ESMEAPI {
	return &ESMEStub{}
}

// Find is API call with trace log
func (s *ESMEStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.ESMEFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("ESMEStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *ESMEStub) Create(ctx context.Context, param *sacloud.ESMECreateRequest) (*sacloud.ESME, error) {
	if s.CreateStubResult == nil {
		log.Fatal("ESMEStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.ESME, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *ESMEStub) Read(ctx context.Context, id types.ID) (*sacloud.ESME, error) {
	if s.ReadStubResult == nil {
		log.Fatal("ESMEStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.ESME, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *ESMEStub) Update(ctx context.Context, id types.ID, param *sacloud.ESMEUpdateRequest) (*sacloud.ESME, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("ESMEStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.ESME, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *ESMEStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("ESMEStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// SendMessageWithGeneratedOTP is API call with trace log
func (s *ESMEStub) SendMessageWithGeneratedOTP(ctx context.Context, id types.ID, param *sacloud.ESMESendMessageWithGeneratedOTPRequest) (*sacloud.ESMESendMessageResult, error) {
	if s.SendMessageWithGeneratedOTPStubResult == nil {
		log.Fatal("ESMEStub.SendMessageWithGeneratedOTPStubResult is not set")
	}
	return s.SendMessageWithGeneratedOTPStubResult.ESMESendMessageResult, s.SendMessageWithGeneratedOTPStubResult.Err
}

// SendMessageWithInputtedOTP is API call with trace log
func (s *ESMEStub) SendMessageWithInputtedOTP(ctx context.Context, id types.ID, param *sacloud.ESMESendMessageWithInputtedOTPRequest) (*sacloud.ESMESendMessageResult, error) {
	if s.SendMessageWithInputtedOTPStubResult == nil {
		log.Fatal("ESMEStub.SendMessageWithInputtedOTPStubResult is not set")
	}
	return s.SendMessageWithInputtedOTPStubResult.ESMESendMessageResult, s.SendMessageWithInputtedOTPStubResult.Err
}

// Logs is API call with trace log
func (s *ESMEStub) Logs(ctx context.Context, id types.ID) ([]*sacloud.ESMELogs, error) {
	if s.LogsStubResult == nil {
		log.Fatal("ESMEStub.LogsStubResult is not set")
	}
	return s.LogsStubResult.Logs, s.LogsStubResult.Err
}

/*************************************************
* GSLBStub
*************************************************/

// GSLBFindStubResult is expected values of the Find operation
type GSLBFindStubResult struct {
	Values *sacloud.GSLBFindResult
	Err    error
}

// GSLBCreateStubResult is expected values of the Create operation
type GSLBCreateStubResult struct {
	GSLB *sacloud.GSLB
	Err  error
}

// GSLBReadStubResult is expected values of the Read operation
type GSLBReadStubResult struct {
	GSLB *sacloud.GSLB
	Err  error
}

// GSLBUpdateStubResult is expected values of the Update operation
type GSLBUpdateStubResult struct {
	GSLB *sacloud.GSLB
	Err  error
}

// GSLBUpdateSettingsStubResult is expected values of the UpdateSettings operation
type GSLBUpdateSettingsStubResult struct {
	GSLB *sacloud.GSLB
	Err  error
}

// GSLBDeleteStubResult is expected values of the Delete operation
type GSLBDeleteStubResult struct {
	Err error
}

// GSLBStub is for trace GSLBOp operations
type GSLBStub struct {
	FindStubResult           *GSLBFindStubResult
	CreateStubResult         *GSLBCreateStubResult
	ReadStubResult           *GSLBReadStubResult
	UpdateStubResult         *GSLBUpdateStubResult
	UpdateSettingsStubResult *GSLBUpdateSettingsStubResult
	DeleteStubResult         *GSLBDeleteStubResult
}

// NewGSLBStub creates new GSLBStub instance
func NewGSLBStub(caller sacloud.APICaller) sacloud.GSLBAPI {
	return &GSLBStub{}
}

// Find is API call with trace log
func (s *GSLBStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.GSLBFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("GSLBStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *GSLBStub) Create(ctx context.Context, param *sacloud.GSLBCreateRequest) (*sacloud.GSLB, error) {
	if s.CreateStubResult == nil {
		log.Fatal("GSLBStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.GSLB, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *GSLBStub) Read(ctx context.Context, id types.ID) (*sacloud.GSLB, error) {
	if s.ReadStubResult == nil {
		log.Fatal("GSLBStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.GSLB, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *GSLBStub) Update(ctx context.Context, id types.ID, param *sacloud.GSLBUpdateRequest) (*sacloud.GSLB, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("GSLBStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.GSLB, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *GSLBStub) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.GSLBUpdateSettingsRequest) (*sacloud.GSLB, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("GSLBStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.GSLB, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *GSLBStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("GSLBStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* IconStub
*************************************************/

// IconFindStubResult is expected values of the Find operation
type IconFindStubResult struct {
	Values *sacloud.IconFindResult
	Err    error
}

// IconCreateStubResult is expected values of the Create operation
type IconCreateStubResult struct {
	Icon *sacloud.Icon
	Err  error
}

// IconReadStubResult is expected values of the Read operation
type IconReadStubResult struct {
	Icon *sacloud.Icon
	Err  error
}

// IconUpdateStubResult is expected values of the Update operation
type IconUpdateStubResult struct {
	Icon *sacloud.Icon
	Err  error
}

// IconDeleteStubResult is expected values of the Delete operation
type IconDeleteStubResult struct {
	Err error
}

// IconStub is for trace IconOp operations
type IconStub struct {
	FindStubResult   *IconFindStubResult
	CreateStubResult *IconCreateStubResult
	ReadStubResult   *IconReadStubResult
	UpdateStubResult *IconUpdateStubResult
	DeleteStubResult *IconDeleteStubResult
}

// NewIconStub creates new IconStub instance
func NewIconStub(caller sacloud.APICaller) sacloud.IconAPI {
	return &IconStub{}
}

// Find is API call with trace log
func (s *IconStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.IconFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("IconStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *IconStub) Create(ctx context.Context, param *sacloud.IconCreateRequest) (*sacloud.Icon, error) {
	if s.CreateStubResult == nil {
		log.Fatal("IconStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.Icon, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *IconStub) Read(ctx context.Context, id types.ID) (*sacloud.Icon, error) {
	if s.ReadStubResult == nil {
		log.Fatal("IconStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Icon, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *IconStub) Update(ctx context.Context, id types.ID, param *sacloud.IconUpdateRequest) (*sacloud.Icon, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("IconStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.Icon, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *IconStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("IconStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* InterfaceStub
*************************************************/

// InterfaceFindStubResult is expected values of the Find operation
type InterfaceFindStubResult struct {
	Values *sacloud.InterfaceFindResult
	Err    error
}

// InterfaceCreateStubResult is expected values of the Create operation
type InterfaceCreateStubResult struct {
	Interface *sacloud.Interface
	Err       error
}

// InterfaceReadStubResult is expected values of the Read operation
type InterfaceReadStubResult struct {
	Interface *sacloud.Interface
	Err       error
}

// InterfaceUpdateStubResult is expected values of the Update operation
type InterfaceUpdateStubResult struct {
	Interface *sacloud.Interface
	Err       error
}

// InterfaceDeleteStubResult is expected values of the Delete operation
type InterfaceDeleteStubResult struct {
	Err error
}

// InterfaceMonitorStubResult is expected values of the Monitor operation
type InterfaceMonitorStubResult struct {
	InterfaceActivity *sacloud.InterfaceActivity
	Err               error
}

// InterfaceConnectToSharedSegmentStubResult is expected values of the ConnectToSharedSegment operation
type InterfaceConnectToSharedSegmentStubResult struct {
	Err error
}

// InterfaceConnectToSwitchStubResult is expected values of the ConnectToSwitch operation
type InterfaceConnectToSwitchStubResult struct {
	Err error
}

// InterfaceDisconnectFromSwitchStubResult is expected values of the DisconnectFromSwitch operation
type InterfaceDisconnectFromSwitchStubResult struct {
	Err error
}

// InterfaceConnectToPacketFilterStubResult is expected values of the ConnectToPacketFilter operation
type InterfaceConnectToPacketFilterStubResult struct {
	Err error
}

// InterfaceDisconnectFromPacketFilterStubResult is expected values of the DisconnectFromPacketFilter operation
type InterfaceDisconnectFromPacketFilterStubResult struct {
	Err error
}

// InterfaceStub is for trace InterfaceOp operations
type InterfaceStub struct {
	FindStubResult                       *InterfaceFindStubResult
	CreateStubResult                     *InterfaceCreateStubResult
	ReadStubResult                       *InterfaceReadStubResult
	UpdateStubResult                     *InterfaceUpdateStubResult
	DeleteStubResult                     *InterfaceDeleteStubResult
	MonitorStubResult                    *InterfaceMonitorStubResult
	ConnectToSharedSegmentStubResult     *InterfaceConnectToSharedSegmentStubResult
	ConnectToSwitchStubResult            *InterfaceConnectToSwitchStubResult
	DisconnectFromSwitchStubResult       *InterfaceDisconnectFromSwitchStubResult
	ConnectToPacketFilterStubResult      *InterfaceConnectToPacketFilterStubResult
	DisconnectFromPacketFilterStubResult *InterfaceDisconnectFromPacketFilterStubResult
}

// NewInterfaceStub creates new InterfaceStub instance
func NewInterfaceStub(caller sacloud.APICaller) sacloud.InterfaceAPI {
	return &InterfaceStub{}
}

// Find is API call with trace log
func (s *InterfaceStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.InterfaceFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("InterfaceStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *InterfaceStub) Create(ctx context.Context, zone string, param *sacloud.InterfaceCreateRequest) (*sacloud.Interface, error) {
	if s.CreateStubResult == nil {
		log.Fatal("InterfaceStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.Interface, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *InterfaceStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Interface, error) {
	if s.ReadStubResult == nil {
		log.Fatal("InterfaceStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Interface, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *InterfaceStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.InterfaceUpdateRequest) (*sacloud.Interface, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("InterfaceStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.Interface, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *InterfaceStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("InterfaceStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// Monitor is API call with trace log
func (s *InterfaceStub) Monitor(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	if s.MonitorStubResult == nil {
		log.Fatal("InterfaceStub.MonitorStubResult is not set")
	}
	return s.MonitorStubResult.InterfaceActivity, s.MonitorStubResult.Err
}

// ConnectToSharedSegment is API call with trace log
func (s *InterfaceStub) ConnectToSharedSegment(ctx context.Context, zone string, id types.ID) error {
	if s.ConnectToSharedSegmentStubResult == nil {
		log.Fatal("InterfaceStub.ConnectToSharedSegmentStubResult is not set")
	}
	return s.ConnectToSharedSegmentStubResult.Err
}

// ConnectToSwitch is API call with trace log
func (s *InterfaceStub) ConnectToSwitch(ctx context.Context, zone string, id types.ID, switchID types.ID) error {
	if s.ConnectToSwitchStubResult == nil {
		log.Fatal("InterfaceStub.ConnectToSwitchStubResult is not set")
	}
	return s.ConnectToSwitchStubResult.Err
}

// DisconnectFromSwitch is API call with trace log
func (s *InterfaceStub) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID) error {
	if s.DisconnectFromSwitchStubResult == nil {
		log.Fatal("InterfaceStub.DisconnectFromSwitchStubResult is not set")
	}
	return s.DisconnectFromSwitchStubResult.Err
}

// ConnectToPacketFilter is API call with trace log
func (s *InterfaceStub) ConnectToPacketFilter(ctx context.Context, zone string, id types.ID, packetFilterID types.ID) error {
	if s.ConnectToPacketFilterStubResult == nil {
		log.Fatal("InterfaceStub.ConnectToPacketFilterStubResult is not set")
	}
	return s.ConnectToPacketFilterStubResult.Err
}

// DisconnectFromPacketFilter is API call with trace log
func (s *InterfaceStub) DisconnectFromPacketFilter(ctx context.Context, zone string, id types.ID) error {
	if s.DisconnectFromPacketFilterStubResult == nil {
		log.Fatal("InterfaceStub.DisconnectFromPacketFilterStubResult is not set")
	}
	return s.DisconnectFromPacketFilterStubResult.Err
}

/*************************************************
* InternetStub
*************************************************/

// InternetFindStubResult is expected values of the Find operation
type InternetFindStubResult struct {
	Values *sacloud.InternetFindResult
	Err    error
}

// InternetCreateStubResult is expected values of the Create operation
type InternetCreateStubResult struct {
	Internet *sacloud.Internet
	Err      error
}

// InternetReadStubResult is expected values of the Read operation
type InternetReadStubResult struct {
	Internet *sacloud.Internet
	Err      error
}

// InternetUpdateStubResult is expected values of the Update operation
type InternetUpdateStubResult struct {
	Internet *sacloud.Internet
	Err      error
}

// InternetDeleteStubResult is expected values of the Delete operation
type InternetDeleteStubResult struct {
	Err error
}

// InternetUpdateBandWidthStubResult is expected values of the UpdateBandWidth operation
type InternetUpdateBandWidthStubResult struct {
	Internet *sacloud.Internet
	Err      error
}

// InternetAddSubnetStubResult is expected values of the AddSubnet operation
type InternetAddSubnetStubResult struct {
	Subnet *sacloud.InternetSubnetOperationResult
	Err    error
}

// InternetUpdateSubnetStubResult is expected values of the UpdateSubnet operation
type InternetUpdateSubnetStubResult struct {
	Subnet *sacloud.InternetSubnetOperationResult
	Err    error
}

// InternetDeleteSubnetStubResult is expected values of the DeleteSubnet operation
type InternetDeleteSubnetStubResult struct {
	Err error
}

// InternetMonitorStubResult is expected values of the Monitor operation
type InternetMonitorStubResult struct {
	RouterActivity *sacloud.RouterActivity
	Err            error
}

// InternetMonitorRouterStubResult is expected values of the MonitorRouter operation
type InternetMonitorRouterStubResult struct {
	RouterActivity *sacloud.RouterActivity
	Err            error
}

// InternetEnableIPv6StubResult is expected values of the EnableIPv6 operation
type InternetEnableIPv6StubResult struct {
	IPv6Net *sacloud.IPv6NetInfo
	Err     error
}

// InternetDisableIPv6StubResult is expected values of the DisableIPv6 operation
type InternetDisableIPv6StubResult struct {
	Err error
}

// InternetStub is for trace InternetOp operations
type InternetStub struct {
	FindStubResult            *InternetFindStubResult
	CreateStubResult          *InternetCreateStubResult
	ReadStubResult            *InternetReadStubResult
	UpdateStubResult          *InternetUpdateStubResult
	DeleteStubResult          *InternetDeleteStubResult
	UpdateBandWidthStubResult *InternetUpdateBandWidthStubResult
	AddSubnetStubResult       *InternetAddSubnetStubResult
	UpdateSubnetStubResult    *InternetUpdateSubnetStubResult
	DeleteSubnetStubResult    *InternetDeleteSubnetStubResult
	MonitorStubResult         *InternetMonitorStubResult
	MonitorRouterStubResult   *InternetMonitorRouterStubResult
	EnableIPv6StubResult      *InternetEnableIPv6StubResult
	DisableIPv6StubResult     *InternetDisableIPv6StubResult
}

// NewInternetStub creates new InternetStub instance
func NewInternetStub(caller sacloud.APICaller) sacloud.InternetAPI {
	return &InternetStub{}
}

// Find is API call with trace log
func (s *InternetStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.InternetFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("InternetStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *InternetStub) Create(ctx context.Context, zone string, param *sacloud.InternetCreateRequest) (*sacloud.Internet, error) {
	if s.CreateStubResult == nil {
		log.Fatal("InternetStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.Internet, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *InternetStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Internet, error) {
	if s.ReadStubResult == nil {
		log.Fatal("InternetStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Internet, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *InternetStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.InternetUpdateRequest) (*sacloud.Internet, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("InternetStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.Internet, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *InternetStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("InternetStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// UpdateBandWidth is API call with trace log
func (s *InternetStub) UpdateBandWidth(ctx context.Context, zone string, id types.ID, param *sacloud.InternetUpdateBandWidthRequest) (*sacloud.Internet, error) {
	if s.UpdateBandWidthStubResult == nil {
		log.Fatal("InternetStub.UpdateBandWidthStubResult is not set")
	}
	return s.UpdateBandWidthStubResult.Internet, s.UpdateBandWidthStubResult.Err
}

// AddSubnet is API call with trace log
func (s *InternetStub) AddSubnet(ctx context.Context, zone string, id types.ID, param *sacloud.InternetAddSubnetRequest) (*sacloud.InternetSubnetOperationResult, error) {
	if s.AddSubnetStubResult == nil {
		log.Fatal("InternetStub.AddSubnetStubResult is not set")
	}
	return s.AddSubnetStubResult.Subnet, s.AddSubnetStubResult.Err
}

// UpdateSubnet is API call with trace log
func (s *InternetStub) UpdateSubnet(ctx context.Context, zone string, id types.ID, subnetID types.ID, param *sacloud.InternetUpdateSubnetRequest) (*sacloud.InternetSubnetOperationResult, error) {
	if s.UpdateSubnetStubResult == nil {
		log.Fatal("InternetStub.UpdateSubnetStubResult is not set")
	}
	return s.UpdateSubnetStubResult.Subnet, s.UpdateSubnetStubResult.Err
}

// DeleteSubnet is API call with trace log
func (s *InternetStub) DeleteSubnet(ctx context.Context, zone string, id types.ID, subnetID types.ID) error {
	if s.DeleteSubnetStubResult == nil {
		log.Fatal("InternetStub.DeleteSubnetStubResult is not set")
	}
	return s.DeleteSubnetStubResult.Err
}

// Monitor is API call with trace log
func (s *InternetStub) Monitor(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.RouterActivity, error) {
	if s.MonitorStubResult == nil {
		log.Fatal("InternetStub.MonitorStubResult is not set")
	}
	return s.MonitorStubResult.RouterActivity, s.MonitorStubResult.Err
}

// MonitorRouter is API call with trace log
func (s *InternetStub) MonitorRouter(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.RouterActivity, error) {
	if s.MonitorRouterStubResult == nil {
		log.Fatal("InternetStub.MonitorRouterStubResult is not set")
	}
	return s.MonitorRouterStubResult.RouterActivity, s.MonitorRouterStubResult.Err
}

// EnableIPv6 is API call with trace log
func (s *InternetStub) EnableIPv6(ctx context.Context, zone string, id types.ID) (*sacloud.IPv6NetInfo, error) {
	if s.EnableIPv6StubResult == nil {
		log.Fatal("InternetStub.EnableIPv6StubResult is not set")
	}
	return s.EnableIPv6StubResult.IPv6Net, s.EnableIPv6StubResult.Err
}

// DisableIPv6 is API call with trace log
func (s *InternetStub) DisableIPv6(ctx context.Context, zone string, id types.ID, ipv6netID types.ID) error {
	if s.DisableIPv6StubResult == nil {
		log.Fatal("InternetStub.DisableIPv6StubResult is not set")
	}
	return s.DisableIPv6StubResult.Err
}

/*************************************************
* InternetPlanStub
*************************************************/

// InternetPlanFindStubResult is expected values of the Find operation
type InternetPlanFindStubResult struct {
	Values *sacloud.InternetPlanFindResult
	Err    error
}

// InternetPlanReadStubResult is expected values of the Read operation
type InternetPlanReadStubResult struct {
	InternetPlan *sacloud.InternetPlan
	Err          error
}

// InternetPlanStub is for trace InternetPlanOp operations
type InternetPlanStub struct {
	FindStubResult *InternetPlanFindStubResult
	ReadStubResult *InternetPlanReadStubResult
}

// NewInternetPlanStub creates new InternetPlanStub instance
func NewInternetPlanStub(caller sacloud.APICaller) sacloud.InternetPlanAPI {
	return &InternetPlanStub{}
}

// Find is API call with trace log
func (s *InternetPlanStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.InternetPlanFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("InternetPlanStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Read is API call with trace log
func (s *InternetPlanStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.InternetPlan, error) {
	if s.ReadStubResult == nil {
		log.Fatal("InternetPlanStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.InternetPlan, s.ReadStubResult.Err
}

/*************************************************
* IPAddressStub
*************************************************/

// IPAddressListStubResult is expected values of the List operation
type IPAddressListStubResult struct {
	Values *sacloud.IPAddressListResult
	Err    error
}

// IPAddressReadStubResult is expected values of the Read operation
type IPAddressReadStubResult struct {
	IPAddress *sacloud.IPAddress
	Err       error
}

// IPAddressUpdateHostNameStubResult is expected values of the UpdateHostName operation
type IPAddressUpdateHostNameStubResult struct {
	IPAddress *sacloud.IPAddress
	Err       error
}

// IPAddressStub is for trace IPAddressOp operations
type IPAddressStub struct {
	ListStubResult           *IPAddressListStubResult
	ReadStubResult           *IPAddressReadStubResult
	UpdateHostNameStubResult *IPAddressUpdateHostNameStubResult
}

// NewIPAddressStub creates new IPAddressStub instance
func NewIPAddressStub(caller sacloud.APICaller) sacloud.IPAddressAPI {
	return &IPAddressStub{}
}

// List is API call with trace log
func (s *IPAddressStub) List(ctx context.Context, zone string) (*sacloud.IPAddressListResult, error) {
	if s.ListStubResult == nil {
		log.Fatal("IPAddressStub.ListStubResult is not set")
	}
	return s.ListStubResult.Values, s.ListStubResult.Err
}

// Read is API call with trace log
func (s *IPAddressStub) Read(ctx context.Context, zone string, ipAddress string) (*sacloud.IPAddress, error) {
	if s.ReadStubResult == nil {
		log.Fatal("IPAddressStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.IPAddress, s.ReadStubResult.Err
}

// UpdateHostName is API call with trace log
func (s *IPAddressStub) UpdateHostName(ctx context.Context, zone string, ipAddress string, hostName string) (*sacloud.IPAddress, error) {
	if s.UpdateHostNameStubResult == nil {
		log.Fatal("IPAddressStub.UpdateHostNameStubResult is not set")
	}
	return s.UpdateHostNameStubResult.IPAddress, s.UpdateHostNameStubResult.Err
}

/*************************************************
* IPv6NetStub
*************************************************/

// IPv6NetListStubResult is expected values of the List operation
type IPv6NetListStubResult struct {
	Values *sacloud.IPv6NetListResult
	Err    error
}

// IPv6NetFindStubResult is expected values of the Find operation
type IPv6NetFindStubResult struct {
	Values *sacloud.IPv6NetFindResult
	Err    error
}

// IPv6NetReadStubResult is expected values of the Read operation
type IPv6NetReadStubResult struct {
	IPv6Net *sacloud.IPv6Net
	Err     error
}

// IPv6NetStub is for trace IPv6NetOp operations
type IPv6NetStub struct {
	ListStubResult *IPv6NetListStubResult
	FindStubResult *IPv6NetFindStubResult
	ReadStubResult *IPv6NetReadStubResult
}

// NewIPv6NetStub creates new IPv6NetStub instance
func NewIPv6NetStub(caller sacloud.APICaller) sacloud.IPv6NetAPI {
	return &IPv6NetStub{}
}

// List is API call with trace log
func (s *IPv6NetStub) List(ctx context.Context, zone string) (*sacloud.IPv6NetListResult, error) {
	if s.ListStubResult == nil {
		log.Fatal("IPv6NetStub.ListStubResult is not set")
	}
	return s.ListStubResult.Values, s.ListStubResult.Err
}

// Find is API call with trace log
func (s *IPv6NetStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.IPv6NetFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("IPv6NetStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Read is API call with trace log
func (s *IPv6NetStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.IPv6Net, error) {
	if s.ReadStubResult == nil {
		log.Fatal("IPv6NetStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.IPv6Net, s.ReadStubResult.Err
}

/*************************************************
* IPv6AddrStub
*************************************************/

// IPv6AddrFindStubResult is expected values of the Find operation
type IPv6AddrFindStubResult struct {
	Values *sacloud.IPv6AddrFindResult
	Err    error
}

// IPv6AddrCreateStubResult is expected values of the Create operation
type IPv6AddrCreateStubResult struct {
	IPv6Addr *sacloud.IPv6Addr
	Err      error
}

// IPv6AddrReadStubResult is expected values of the Read operation
type IPv6AddrReadStubResult struct {
	IPv6Addr *sacloud.IPv6Addr
	Err      error
}

// IPv6AddrUpdateStubResult is expected values of the Update operation
type IPv6AddrUpdateStubResult struct {
	IPv6Addr *sacloud.IPv6Addr
	Err      error
}

// IPv6AddrDeleteStubResult is expected values of the Delete operation
type IPv6AddrDeleteStubResult struct {
	Err error
}

// IPv6AddrStub is for trace IPv6AddrOp operations
type IPv6AddrStub struct {
	FindStubResult   *IPv6AddrFindStubResult
	CreateStubResult *IPv6AddrCreateStubResult
	ReadStubResult   *IPv6AddrReadStubResult
	UpdateStubResult *IPv6AddrUpdateStubResult
	DeleteStubResult *IPv6AddrDeleteStubResult
}

// NewIPv6AddrStub creates new IPv6AddrStub instance
func NewIPv6AddrStub(caller sacloud.APICaller) sacloud.IPv6AddrAPI {
	return &IPv6AddrStub{}
}

// Find is API call with trace log
func (s *IPv6AddrStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.IPv6AddrFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("IPv6AddrStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *IPv6AddrStub) Create(ctx context.Context, zone string, param *sacloud.IPv6AddrCreateRequest) (*sacloud.IPv6Addr, error) {
	if s.CreateStubResult == nil {
		log.Fatal("IPv6AddrStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.IPv6Addr, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *IPv6AddrStub) Read(ctx context.Context, zone string, ipv6addr string) (*sacloud.IPv6Addr, error) {
	if s.ReadStubResult == nil {
		log.Fatal("IPv6AddrStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.IPv6Addr, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *IPv6AddrStub) Update(ctx context.Context, zone string, ipv6addr string, param *sacloud.IPv6AddrUpdateRequest) (*sacloud.IPv6Addr, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("IPv6AddrStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.IPv6Addr, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *IPv6AddrStub) Delete(ctx context.Context, zone string, ipv6addr string) error {
	if s.DeleteStubResult == nil {
		log.Fatal("IPv6AddrStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* LicenseStub
*************************************************/

// LicenseFindStubResult is expected values of the Find operation
type LicenseFindStubResult struct {
	Values *sacloud.LicenseFindResult
	Err    error
}

// LicenseCreateStubResult is expected values of the Create operation
type LicenseCreateStubResult struct {
	License *sacloud.License
	Err     error
}

// LicenseReadStubResult is expected values of the Read operation
type LicenseReadStubResult struct {
	License *sacloud.License
	Err     error
}

// LicenseUpdateStubResult is expected values of the Update operation
type LicenseUpdateStubResult struct {
	License *sacloud.License
	Err     error
}

// LicenseDeleteStubResult is expected values of the Delete operation
type LicenseDeleteStubResult struct {
	Err error
}

// LicenseStub is for trace LicenseOp operations
type LicenseStub struct {
	FindStubResult   *LicenseFindStubResult
	CreateStubResult *LicenseCreateStubResult
	ReadStubResult   *LicenseReadStubResult
	UpdateStubResult *LicenseUpdateStubResult
	DeleteStubResult *LicenseDeleteStubResult
}

// NewLicenseStub creates new LicenseStub instance
func NewLicenseStub(caller sacloud.APICaller) sacloud.LicenseAPI {
	return &LicenseStub{}
}

// Find is API call with trace log
func (s *LicenseStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.LicenseFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("LicenseStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *LicenseStub) Create(ctx context.Context, param *sacloud.LicenseCreateRequest) (*sacloud.License, error) {
	if s.CreateStubResult == nil {
		log.Fatal("LicenseStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.License, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *LicenseStub) Read(ctx context.Context, id types.ID) (*sacloud.License, error) {
	if s.ReadStubResult == nil {
		log.Fatal("LicenseStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.License, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *LicenseStub) Update(ctx context.Context, id types.ID, param *sacloud.LicenseUpdateRequest) (*sacloud.License, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("LicenseStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.License, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *LicenseStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("LicenseStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* LicenseInfoStub
*************************************************/

// LicenseInfoFindStubResult is expected values of the Find operation
type LicenseInfoFindStubResult struct {
	Values *sacloud.LicenseInfoFindResult
	Err    error
}

// LicenseInfoReadStubResult is expected values of the Read operation
type LicenseInfoReadStubResult struct {
	LicenseInfo *sacloud.LicenseInfo
	Err         error
}

// LicenseInfoStub is for trace LicenseInfoOp operations
type LicenseInfoStub struct {
	FindStubResult *LicenseInfoFindStubResult
	ReadStubResult *LicenseInfoReadStubResult
}

// NewLicenseInfoStub creates new LicenseInfoStub instance
func NewLicenseInfoStub(caller sacloud.APICaller) sacloud.LicenseInfoAPI {
	return &LicenseInfoStub{}
}

// Find is API call with trace log
func (s *LicenseInfoStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.LicenseInfoFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("LicenseInfoStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Read is API call with trace log
func (s *LicenseInfoStub) Read(ctx context.Context, id types.ID) (*sacloud.LicenseInfo, error) {
	if s.ReadStubResult == nil {
		log.Fatal("LicenseInfoStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.LicenseInfo, s.ReadStubResult.Err
}

/*************************************************
* LoadBalancerStub
*************************************************/

// LoadBalancerFindStubResult is expected values of the Find operation
type LoadBalancerFindStubResult struct {
	Values *sacloud.LoadBalancerFindResult
	Err    error
}

// LoadBalancerCreateStubResult is expected values of the Create operation
type LoadBalancerCreateStubResult struct {
	LoadBalancer *sacloud.LoadBalancer
	Err          error
}

// LoadBalancerReadStubResult is expected values of the Read operation
type LoadBalancerReadStubResult struct {
	LoadBalancer *sacloud.LoadBalancer
	Err          error
}

// LoadBalancerUpdateStubResult is expected values of the Update operation
type LoadBalancerUpdateStubResult struct {
	LoadBalancer *sacloud.LoadBalancer
	Err          error
}

// LoadBalancerUpdateSettingsStubResult is expected values of the UpdateSettings operation
type LoadBalancerUpdateSettingsStubResult struct {
	LoadBalancer *sacloud.LoadBalancer
	Err          error
}

// LoadBalancerDeleteStubResult is expected values of the Delete operation
type LoadBalancerDeleteStubResult struct {
	Err error
}

// LoadBalancerConfigStubResult is expected values of the Config operation
type LoadBalancerConfigStubResult struct {
	Err error
}

// LoadBalancerBootStubResult is expected values of the Boot operation
type LoadBalancerBootStubResult struct {
	Err error
}

// LoadBalancerShutdownStubResult is expected values of the Shutdown operation
type LoadBalancerShutdownStubResult struct {
	Err error
}

// LoadBalancerResetStubResult is expected values of the Reset operation
type LoadBalancerResetStubResult struct {
	Err error
}

// LoadBalancerMonitorCPUStubResult is expected values of the MonitorCPU operation
type LoadBalancerMonitorCPUStubResult struct {
	CPUTimeActivity *sacloud.CPUTimeActivity
	Err             error
}

// LoadBalancerMonitorInterfaceStubResult is expected values of the MonitorInterface operation
type LoadBalancerMonitorInterfaceStubResult struct {
	InterfaceActivity *sacloud.InterfaceActivity
	Err               error
}

// LoadBalancerStatusStubResult is expected values of the Status operation
type LoadBalancerStatusStubResult struct {
	Values *sacloud.LoadBalancerStatusResult
	Err    error
}

// LoadBalancerStub is for trace LoadBalancerOp operations
type LoadBalancerStub struct {
	FindStubResult             *LoadBalancerFindStubResult
	CreateStubResult           *LoadBalancerCreateStubResult
	ReadStubResult             *LoadBalancerReadStubResult
	UpdateStubResult           *LoadBalancerUpdateStubResult
	UpdateSettingsStubResult   *LoadBalancerUpdateSettingsStubResult
	DeleteStubResult           *LoadBalancerDeleteStubResult
	ConfigStubResult           *LoadBalancerConfigStubResult
	BootStubResult             *LoadBalancerBootStubResult
	ShutdownStubResult         *LoadBalancerShutdownStubResult
	ResetStubResult            *LoadBalancerResetStubResult
	MonitorCPUStubResult       *LoadBalancerMonitorCPUStubResult
	MonitorInterfaceStubResult *LoadBalancerMonitorInterfaceStubResult
	StatusStubResult           *LoadBalancerStatusStubResult
}

// NewLoadBalancerStub creates new LoadBalancerStub instance
func NewLoadBalancerStub(caller sacloud.APICaller) sacloud.LoadBalancerAPI {
	return &LoadBalancerStub{}
}

// Find is API call with trace log
func (s *LoadBalancerStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.LoadBalancerFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("LoadBalancerStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *LoadBalancerStub) Create(ctx context.Context, zone string, param *sacloud.LoadBalancerCreateRequest) (*sacloud.LoadBalancer, error) {
	if s.CreateStubResult == nil {
		log.Fatal("LoadBalancerStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.LoadBalancer, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *LoadBalancerStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.LoadBalancer, error) {
	if s.ReadStubResult == nil {
		log.Fatal("LoadBalancerStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.LoadBalancer, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *LoadBalancerStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.LoadBalancerUpdateRequest) (*sacloud.LoadBalancer, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("LoadBalancerStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.LoadBalancer, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *LoadBalancerStub) UpdateSettings(ctx context.Context, zone string, id types.ID, param *sacloud.LoadBalancerUpdateSettingsRequest) (*sacloud.LoadBalancer, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("LoadBalancerStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.LoadBalancer, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *LoadBalancerStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("LoadBalancerStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// Config is API call with trace log
func (s *LoadBalancerStub) Config(ctx context.Context, zone string, id types.ID) error {
	if s.ConfigStubResult == nil {
		log.Fatal("LoadBalancerStub.ConfigStubResult is not set")
	}
	return s.ConfigStubResult.Err
}

// Boot is API call with trace log
func (s *LoadBalancerStub) Boot(ctx context.Context, zone string, id types.ID) error {
	if s.BootStubResult == nil {
		log.Fatal("LoadBalancerStub.BootStubResult is not set")
	}
	return s.BootStubResult.Err
}

// Shutdown is API call with trace log
func (s *LoadBalancerStub) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	if s.ShutdownStubResult == nil {
		log.Fatal("LoadBalancerStub.ShutdownStubResult is not set")
	}
	return s.ShutdownStubResult.Err
}

// Reset is API call with trace log
func (s *LoadBalancerStub) Reset(ctx context.Context, zone string, id types.ID) error {
	if s.ResetStubResult == nil {
		log.Fatal("LoadBalancerStub.ResetStubResult is not set")
	}
	return s.ResetStubResult.Err
}

// MonitorCPU is API call with trace log
func (s *LoadBalancerStub) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	if s.MonitorCPUStubResult == nil {
		log.Fatal("LoadBalancerStub.MonitorCPUStubResult is not set")
	}
	return s.MonitorCPUStubResult.CPUTimeActivity, s.MonitorCPUStubResult.Err
}

// MonitorInterface is API call with trace log
func (s *LoadBalancerStub) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	if s.MonitorInterfaceStubResult == nil {
		log.Fatal("LoadBalancerStub.MonitorInterfaceStubResult is not set")
	}
	return s.MonitorInterfaceStubResult.InterfaceActivity, s.MonitorInterfaceStubResult.Err
}

// Status is API call with trace log
func (s *LoadBalancerStub) Status(ctx context.Context, zone string, id types.ID) (*sacloud.LoadBalancerStatusResult, error) {
	if s.StatusStubResult == nil {
		log.Fatal("LoadBalancerStub.StatusStubResult is not set")
	}
	return s.StatusStubResult.Values, s.StatusStubResult.Err
}

/*************************************************
* LocalRouterStub
*************************************************/

// LocalRouterFindStubResult is expected values of the Find operation
type LocalRouterFindStubResult struct {
	Values *sacloud.LocalRouterFindResult
	Err    error
}

// LocalRouterCreateStubResult is expected values of the Create operation
type LocalRouterCreateStubResult struct {
	LocalRouter *sacloud.LocalRouter
	Err         error
}

// LocalRouterReadStubResult is expected values of the Read operation
type LocalRouterReadStubResult struct {
	LocalRouter *sacloud.LocalRouter
	Err         error
}

// LocalRouterUpdateStubResult is expected values of the Update operation
type LocalRouterUpdateStubResult struct {
	LocalRouter *sacloud.LocalRouter
	Err         error
}

// LocalRouterUpdateSettingsStubResult is expected values of the UpdateSettings operation
type LocalRouterUpdateSettingsStubResult struct {
	LocalRouter *sacloud.LocalRouter
	Err         error
}

// LocalRouterDeleteStubResult is expected values of the Delete operation
type LocalRouterDeleteStubResult struct {
	Err error
}

// LocalRouterHealthStatusStubResult is expected values of the HealthStatus operation
type LocalRouterHealthStatusStubResult struct {
	LocalRouterHealth *sacloud.LocalRouterHealth
	Err               error
}

// LocalRouterMonitorLocalRouterStubResult is expected values of the MonitorLocalRouter operation
type LocalRouterMonitorLocalRouterStubResult struct {
	LocalRouterActivity *sacloud.LocalRouterActivity
	Err                 error
}

// LocalRouterStub is for trace LocalRouterOp operations
type LocalRouterStub struct {
	FindStubResult               *LocalRouterFindStubResult
	CreateStubResult             *LocalRouterCreateStubResult
	ReadStubResult               *LocalRouterReadStubResult
	UpdateStubResult             *LocalRouterUpdateStubResult
	UpdateSettingsStubResult     *LocalRouterUpdateSettingsStubResult
	DeleteStubResult             *LocalRouterDeleteStubResult
	HealthStatusStubResult       *LocalRouterHealthStatusStubResult
	MonitorLocalRouterStubResult *LocalRouterMonitorLocalRouterStubResult
}

// NewLocalRouterStub creates new LocalRouterStub instance
func NewLocalRouterStub(caller sacloud.APICaller) sacloud.LocalRouterAPI {
	return &LocalRouterStub{}
}

// Find is API call with trace log
func (s *LocalRouterStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.LocalRouterFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("LocalRouterStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *LocalRouterStub) Create(ctx context.Context, param *sacloud.LocalRouterCreateRequest) (*sacloud.LocalRouter, error) {
	if s.CreateStubResult == nil {
		log.Fatal("LocalRouterStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.LocalRouter, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *LocalRouterStub) Read(ctx context.Context, id types.ID) (*sacloud.LocalRouter, error) {
	if s.ReadStubResult == nil {
		log.Fatal("LocalRouterStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.LocalRouter, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *LocalRouterStub) Update(ctx context.Context, id types.ID, param *sacloud.LocalRouterUpdateRequest) (*sacloud.LocalRouter, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("LocalRouterStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.LocalRouter, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *LocalRouterStub) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.LocalRouterUpdateSettingsRequest) (*sacloud.LocalRouter, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("LocalRouterStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.LocalRouter, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *LocalRouterStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("LocalRouterStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// HealthStatus is API call with trace log
func (s *LocalRouterStub) HealthStatus(ctx context.Context, id types.ID) (*sacloud.LocalRouterHealth, error) {
	if s.HealthStatusStubResult == nil {
		log.Fatal("LocalRouterStub.HealthStatusStubResult is not set")
	}
	return s.HealthStatusStubResult.LocalRouterHealth, s.HealthStatusStubResult.Err
}

// MonitorLocalRouter is API call with trace log
func (s *LocalRouterStub) MonitorLocalRouter(ctx context.Context, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.LocalRouterActivity, error) {
	if s.MonitorLocalRouterStubResult == nil {
		log.Fatal("LocalRouterStub.MonitorLocalRouterStubResult is not set")
	}
	return s.MonitorLocalRouterStubResult.LocalRouterActivity, s.MonitorLocalRouterStubResult.Err
}

/*************************************************
* MobileGatewayStub
*************************************************/

// MobileGatewayFindStubResult is expected values of the Find operation
type MobileGatewayFindStubResult struct {
	Values *sacloud.MobileGatewayFindResult
	Err    error
}

// MobileGatewayCreateStubResult is expected values of the Create operation
type MobileGatewayCreateStubResult struct {
	MobileGateway *sacloud.MobileGateway
	Err           error
}

// MobileGatewayReadStubResult is expected values of the Read operation
type MobileGatewayReadStubResult struct {
	MobileGateway *sacloud.MobileGateway
	Err           error
}

// MobileGatewayUpdateStubResult is expected values of the Update operation
type MobileGatewayUpdateStubResult struct {
	MobileGateway *sacloud.MobileGateway
	Err           error
}

// MobileGatewayUpdateSettingsStubResult is expected values of the UpdateSettings operation
type MobileGatewayUpdateSettingsStubResult struct {
	MobileGateway *sacloud.MobileGateway
	Err           error
}

// MobileGatewayDeleteStubResult is expected values of the Delete operation
type MobileGatewayDeleteStubResult struct {
	Err error
}

// MobileGatewayConfigStubResult is expected values of the Config operation
type MobileGatewayConfigStubResult struct {
	Err error
}

// MobileGatewayBootStubResult is expected values of the Boot operation
type MobileGatewayBootStubResult struct {
	Err error
}

// MobileGatewayShutdownStubResult is expected values of the Shutdown operation
type MobileGatewayShutdownStubResult struct {
	Err error
}

// MobileGatewayResetStubResult is expected values of the Reset operation
type MobileGatewayResetStubResult struct {
	Err error
}

// MobileGatewayConnectToSwitchStubResult is expected values of the ConnectToSwitch operation
type MobileGatewayConnectToSwitchStubResult struct {
	Err error
}

// MobileGatewayDisconnectFromSwitchStubResult is expected values of the DisconnectFromSwitch operation
type MobileGatewayDisconnectFromSwitchStubResult struct {
	Err error
}

// MobileGatewayGetDNSStubResult is expected values of the GetDNS operation
type MobileGatewayGetDNSStubResult struct {
	SIMGroup *sacloud.MobileGatewayDNSSetting
	Err      error
}

// MobileGatewaySetDNSStubResult is expected values of the SetDNS operation
type MobileGatewaySetDNSStubResult struct {
	Err error
}

// MobileGatewayGetSIMRoutesStubResult is expected values of the GetSIMRoutes operation
type MobileGatewayGetSIMRoutesStubResult struct {
	SIMRoutes sacloud.MobileGatewaySIMRoutes
	Err       error
}

// MobileGatewaySetSIMRoutesStubResult is expected values of the SetSIMRoutes operation
type MobileGatewaySetSIMRoutesStubResult struct {
	Err error
}

// MobileGatewayListSIMStubResult is expected values of the ListSIM operation
type MobileGatewayListSIMStubResult struct {
	SIM sacloud.MobileGatewaySIMs
	Err error
}

// MobileGatewayAddSIMStubResult is expected values of the AddSIM operation
type MobileGatewayAddSIMStubResult struct {
	Err error
}

// MobileGatewayDeleteSIMStubResult is expected values of the DeleteSIM operation
type MobileGatewayDeleteSIMStubResult struct {
	Err error
}

// MobileGatewayLogsStubResult is expected values of the Logs operation
type MobileGatewayLogsStubResult struct {
	Logs []*sacloud.MobileGatewaySIMLogs
	Err  error
}

// MobileGatewayGetTrafficConfigStubResult is expected values of the GetTrafficConfig operation
type MobileGatewayGetTrafficConfigStubResult struct {
	TrafficMonitoring *sacloud.MobileGatewayTrafficControl
	Err               error
}

// MobileGatewaySetTrafficConfigStubResult is expected values of the SetTrafficConfig operation
type MobileGatewaySetTrafficConfigStubResult struct {
	Err error
}

// MobileGatewayDeleteTrafficConfigStubResult is expected values of the DeleteTrafficConfig operation
type MobileGatewayDeleteTrafficConfigStubResult struct {
	Err error
}

// MobileGatewayTrafficStatusStubResult is expected values of the TrafficStatus operation
type MobileGatewayTrafficStatusStubResult struct {
	TrafficStatus *sacloud.MobileGatewayTrafficStatus
	Err           error
}

// MobileGatewayMonitorInterfaceStubResult is expected values of the MonitorInterface operation
type MobileGatewayMonitorInterfaceStubResult struct {
	InterfaceActivity *sacloud.InterfaceActivity
	Err               error
}

// MobileGatewayStub is for trace MobileGatewayOp operations
type MobileGatewayStub struct {
	FindStubResult                 *MobileGatewayFindStubResult
	CreateStubResult               *MobileGatewayCreateStubResult
	ReadStubResult                 *MobileGatewayReadStubResult
	UpdateStubResult               *MobileGatewayUpdateStubResult
	UpdateSettingsStubResult       *MobileGatewayUpdateSettingsStubResult
	DeleteStubResult               *MobileGatewayDeleteStubResult
	ConfigStubResult               *MobileGatewayConfigStubResult
	BootStubResult                 *MobileGatewayBootStubResult
	ShutdownStubResult             *MobileGatewayShutdownStubResult
	ResetStubResult                *MobileGatewayResetStubResult
	ConnectToSwitchStubResult      *MobileGatewayConnectToSwitchStubResult
	DisconnectFromSwitchStubResult *MobileGatewayDisconnectFromSwitchStubResult
	GetDNSStubResult               *MobileGatewayGetDNSStubResult
	SetDNSStubResult               *MobileGatewaySetDNSStubResult
	GetSIMRoutesStubResult         *MobileGatewayGetSIMRoutesStubResult
	SetSIMRoutesStubResult         *MobileGatewaySetSIMRoutesStubResult
	ListSIMStubResult              *MobileGatewayListSIMStubResult
	AddSIMStubResult               *MobileGatewayAddSIMStubResult
	DeleteSIMStubResult            *MobileGatewayDeleteSIMStubResult
	LogsStubResult                 *MobileGatewayLogsStubResult
	GetTrafficConfigStubResult     *MobileGatewayGetTrafficConfigStubResult
	SetTrafficConfigStubResult     *MobileGatewaySetTrafficConfigStubResult
	DeleteTrafficConfigStubResult  *MobileGatewayDeleteTrafficConfigStubResult
	TrafficStatusStubResult        *MobileGatewayTrafficStatusStubResult
	MonitorInterfaceStubResult     *MobileGatewayMonitorInterfaceStubResult
}

// NewMobileGatewayStub creates new MobileGatewayStub instance
func NewMobileGatewayStub(caller sacloud.APICaller) sacloud.MobileGatewayAPI {
	return &MobileGatewayStub{}
}

// Find is API call with trace log
func (s *MobileGatewayStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.MobileGatewayFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("MobileGatewayStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *MobileGatewayStub) Create(ctx context.Context, zone string, param *sacloud.MobileGatewayCreateRequest) (*sacloud.MobileGateway, error) {
	if s.CreateStubResult == nil {
		log.Fatal("MobileGatewayStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.MobileGateway, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *MobileGatewayStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.MobileGateway, error) {
	if s.ReadStubResult == nil {
		log.Fatal("MobileGatewayStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.MobileGateway, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *MobileGatewayStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.MobileGatewayUpdateRequest) (*sacloud.MobileGateway, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("MobileGatewayStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.MobileGateway, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *MobileGatewayStub) UpdateSettings(ctx context.Context, zone string, id types.ID, param *sacloud.MobileGatewayUpdateSettingsRequest) (*sacloud.MobileGateway, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("MobileGatewayStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.MobileGateway, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *MobileGatewayStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("MobileGatewayStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// Config is API call with trace log
func (s *MobileGatewayStub) Config(ctx context.Context, zone string, id types.ID) error {
	if s.ConfigStubResult == nil {
		log.Fatal("MobileGatewayStub.ConfigStubResult is not set")
	}
	return s.ConfigStubResult.Err
}

// Boot is API call with trace log
func (s *MobileGatewayStub) Boot(ctx context.Context, zone string, id types.ID) error {
	if s.BootStubResult == nil {
		log.Fatal("MobileGatewayStub.BootStubResult is not set")
	}
	return s.BootStubResult.Err
}

// Shutdown is API call with trace log
func (s *MobileGatewayStub) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	if s.ShutdownStubResult == nil {
		log.Fatal("MobileGatewayStub.ShutdownStubResult is not set")
	}
	return s.ShutdownStubResult.Err
}

// Reset is API call with trace log
func (s *MobileGatewayStub) Reset(ctx context.Context, zone string, id types.ID) error {
	if s.ResetStubResult == nil {
		log.Fatal("MobileGatewayStub.ResetStubResult is not set")
	}
	return s.ResetStubResult.Err
}

// ConnectToSwitch is API call with trace log
func (s *MobileGatewayStub) ConnectToSwitch(ctx context.Context, zone string, id types.ID, switchID types.ID) error {
	if s.ConnectToSwitchStubResult == nil {
		log.Fatal("MobileGatewayStub.ConnectToSwitchStubResult is not set")
	}
	return s.ConnectToSwitchStubResult.Err
}

// DisconnectFromSwitch is API call with trace log
func (s *MobileGatewayStub) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID) error {
	if s.DisconnectFromSwitchStubResult == nil {
		log.Fatal("MobileGatewayStub.DisconnectFromSwitchStubResult is not set")
	}
	return s.DisconnectFromSwitchStubResult.Err
}

// GetDNS is API call with trace log
func (s *MobileGatewayStub) GetDNS(ctx context.Context, zone string, id types.ID) (*sacloud.MobileGatewayDNSSetting, error) {
	if s.GetDNSStubResult == nil {
		log.Fatal("MobileGatewayStub.GetDNSStubResult is not set")
	}
	return s.GetDNSStubResult.SIMGroup, s.GetDNSStubResult.Err
}

// SetDNS is API call with trace log
func (s *MobileGatewayStub) SetDNS(ctx context.Context, zone string, id types.ID, param *sacloud.MobileGatewayDNSSetting) error {
	if s.SetDNSStubResult == nil {
		log.Fatal("MobileGatewayStub.SetDNSStubResult is not set")
	}
	return s.SetDNSStubResult.Err
}

// GetSIMRoutes is API call with trace log
func (s *MobileGatewayStub) GetSIMRoutes(ctx context.Context, zone string, id types.ID) (sacloud.MobileGatewaySIMRoutes, error) {
	if s.GetSIMRoutesStubResult == nil {
		log.Fatal("MobileGatewayStub.GetSIMRoutesStubResult is not set")
	}
	return s.GetSIMRoutesStubResult.SIMRoutes, s.GetSIMRoutesStubResult.Err
}

// SetSIMRoutes is API call with trace log
func (s *MobileGatewayStub) SetSIMRoutes(ctx context.Context, zone string, id types.ID, param []*sacloud.MobileGatewaySIMRouteParam) error {
	if s.SetSIMRoutesStubResult == nil {
		log.Fatal("MobileGatewayStub.SetSIMRoutesStubResult is not set")
	}
	return s.SetSIMRoutesStubResult.Err
}

// ListSIM is API call with trace log
func (s *MobileGatewayStub) ListSIM(ctx context.Context, zone string, id types.ID) (sacloud.MobileGatewaySIMs, error) {
	if s.ListSIMStubResult == nil {
		log.Fatal("MobileGatewayStub.ListSIMStubResult is not set")
	}
	return s.ListSIMStubResult.SIM, s.ListSIMStubResult.Err
}

// AddSIM is API call with trace log
func (s *MobileGatewayStub) AddSIM(ctx context.Context, zone string, id types.ID, param *sacloud.MobileGatewayAddSIMRequest) error {
	if s.AddSIMStubResult == nil {
		log.Fatal("MobileGatewayStub.AddSIMStubResult is not set")
	}
	return s.AddSIMStubResult.Err
}

// DeleteSIM is API call with trace log
func (s *MobileGatewayStub) DeleteSIM(ctx context.Context, zone string, id types.ID, simID types.ID) error {
	if s.DeleteSIMStubResult == nil {
		log.Fatal("MobileGatewayStub.DeleteSIMStubResult is not set")
	}
	return s.DeleteSIMStubResult.Err
}

// Logs is API call with trace log
func (s *MobileGatewayStub) Logs(ctx context.Context, zone string, id types.ID) ([]*sacloud.MobileGatewaySIMLogs, error) {
	if s.LogsStubResult == nil {
		log.Fatal("MobileGatewayStub.LogsStubResult is not set")
	}
	return s.LogsStubResult.Logs, s.LogsStubResult.Err
}

// GetTrafficConfig is API call with trace log
func (s *MobileGatewayStub) GetTrafficConfig(ctx context.Context, zone string, id types.ID) (*sacloud.MobileGatewayTrafficControl, error) {
	if s.GetTrafficConfigStubResult == nil {
		log.Fatal("MobileGatewayStub.GetTrafficConfigStubResult is not set")
	}
	return s.GetTrafficConfigStubResult.TrafficMonitoring, s.GetTrafficConfigStubResult.Err
}

// SetTrafficConfig is API call with trace log
func (s *MobileGatewayStub) SetTrafficConfig(ctx context.Context, zone string, id types.ID, param *sacloud.MobileGatewayTrafficControl) error {
	if s.SetTrafficConfigStubResult == nil {
		log.Fatal("MobileGatewayStub.SetTrafficConfigStubResult is not set")
	}
	return s.SetTrafficConfigStubResult.Err
}

// DeleteTrafficConfig is API call with trace log
func (s *MobileGatewayStub) DeleteTrafficConfig(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteTrafficConfigStubResult == nil {
		log.Fatal("MobileGatewayStub.DeleteTrafficConfigStubResult is not set")
	}
	return s.DeleteTrafficConfigStubResult.Err
}

// TrafficStatus is API call with trace log
func (s *MobileGatewayStub) TrafficStatus(ctx context.Context, zone string, id types.ID) (*sacloud.MobileGatewayTrafficStatus, error) {
	if s.TrafficStatusStubResult == nil {
		log.Fatal("MobileGatewayStub.TrafficStatusStubResult is not set")
	}
	return s.TrafficStatusStubResult.TrafficStatus, s.TrafficStatusStubResult.Err
}

// MonitorInterface is API call with trace log
func (s *MobileGatewayStub) MonitorInterface(ctx context.Context, zone string, id types.ID, index int, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	if s.MonitorInterfaceStubResult == nil {
		log.Fatal("MobileGatewayStub.MonitorInterfaceStubResult is not set")
	}
	return s.MonitorInterfaceStubResult.InterfaceActivity, s.MonitorInterfaceStubResult.Err
}

/*************************************************
* NFSStub
*************************************************/

// NFSFindStubResult is expected values of the Find operation
type NFSFindStubResult struct {
	Values *sacloud.NFSFindResult
	Err    error
}

// NFSCreateStubResult is expected values of the Create operation
type NFSCreateStubResult struct {
	NFS *sacloud.NFS
	Err error
}

// NFSReadStubResult is expected values of the Read operation
type NFSReadStubResult struct {
	NFS *sacloud.NFS
	Err error
}

// NFSUpdateStubResult is expected values of the Update operation
type NFSUpdateStubResult struct {
	NFS *sacloud.NFS
	Err error
}

// NFSDeleteStubResult is expected values of the Delete operation
type NFSDeleteStubResult struct {
	Err error
}

// NFSBootStubResult is expected values of the Boot operation
type NFSBootStubResult struct {
	Err error
}

// NFSShutdownStubResult is expected values of the Shutdown operation
type NFSShutdownStubResult struct {
	Err error
}

// NFSResetStubResult is expected values of the Reset operation
type NFSResetStubResult struct {
	Err error
}

// NFSMonitorCPUStubResult is expected values of the MonitorCPU operation
type NFSMonitorCPUStubResult struct {
	CPUTimeActivity *sacloud.CPUTimeActivity
	Err             error
}

// NFSMonitorFreeDiskSizeStubResult is expected values of the MonitorFreeDiskSize operation
type NFSMonitorFreeDiskSizeStubResult struct {
	FreeDiskSizeActivity *sacloud.FreeDiskSizeActivity
	Err                  error
}

// NFSMonitorInterfaceStubResult is expected values of the MonitorInterface operation
type NFSMonitorInterfaceStubResult struct {
	InterfaceActivity *sacloud.InterfaceActivity
	Err               error
}

// NFSStub is for trace NFSOp operations
type NFSStub struct {
	FindStubResult                *NFSFindStubResult
	CreateStubResult              *NFSCreateStubResult
	ReadStubResult                *NFSReadStubResult
	UpdateStubResult              *NFSUpdateStubResult
	DeleteStubResult              *NFSDeleteStubResult
	BootStubResult                *NFSBootStubResult
	ShutdownStubResult            *NFSShutdownStubResult
	ResetStubResult               *NFSResetStubResult
	MonitorCPUStubResult          *NFSMonitorCPUStubResult
	MonitorFreeDiskSizeStubResult *NFSMonitorFreeDiskSizeStubResult
	MonitorInterfaceStubResult    *NFSMonitorInterfaceStubResult
}

// NewNFSStub creates new NFSStub instance
func NewNFSStub(caller sacloud.APICaller) sacloud.NFSAPI {
	return &NFSStub{}
}

// Find is API call with trace log
func (s *NFSStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.NFSFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("NFSStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *NFSStub) Create(ctx context.Context, zone string, param *sacloud.NFSCreateRequest) (*sacloud.NFS, error) {
	if s.CreateStubResult == nil {
		log.Fatal("NFSStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.NFS, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *NFSStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.NFS, error) {
	if s.ReadStubResult == nil {
		log.Fatal("NFSStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.NFS, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *NFSStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.NFSUpdateRequest) (*sacloud.NFS, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("NFSStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.NFS, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *NFSStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("NFSStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// Boot is API call with trace log
func (s *NFSStub) Boot(ctx context.Context, zone string, id types.ID) error {
	if s.BootStubResult == nil {
		log.Fatal("NFSStub.BootStubResult is not set")
	}
	return s.BootStubResult.Err
}

// Shutdown is API call with trace log
func (s *NFSStub) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	if s.ShutdownStubResult == nil {
		log.Fatal("NFSStub.ShutdownStubResult is not set")
	}
	return s.ShutdownStubResult.Err
}

// Reset is API call with trace log
func (s *NFSStub) Reset(ctx context.Context, zone string, id types.ID) error {
	if s.ResetStubResult == nil {
		log.Fatal("NFSStub.ResetStubResult is not set")
	}
	return s.ResetStubResult.Err
}

// MonitorCPU is API call with trace log
func (s *NFSStub) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	if s.MonitorCPUStubResult == nil {
		log.Fatal("NFSStub.MonitorCPUStubResult is not set")
	}
	return s.MonitorCPUStubResult.CPUTimeActivity, s.MonitorCPUStubResult.Err
}

// MonitorFreeDiskSize is API call with trace log
func (s *NFSStub) MonitorFreeDiskSize(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.FreeDiskSizeActivity, error) {
	if s.MonitorFreeDiskSizeStubResult == nil {
		log.Fatal("NFSStub.MonitorFreeDiskSizeStubResult is not set")
	}
	return s.MonitorFreeDiskSizeStubResult.FreeDiskSizeActivity, s.MonitorFreeDiskSizeStubResult.Err
}

// MonitorInterface is API call with trace log
func (s *NFSStub) MonitorInterface(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	if s.MonitorInterfaceStubResult == nil {
		log.Fatal("NFSStub.MonitorInterfaceStubResult is not set")
	}
	return s.MonitorInterfaceStubResult.InterfaceActivity, s.MonitorInterfaceStubResult.Err
}

/*************************************************
* NoteStub
*************************************************/

// NoteFindStubResult is expected values of the Find operation
type NoteFindStubResult struct {
	Values *sacloud.NoteFindResult
	Err    error
}

// NoteCreateStubResult is expected values of the Create operation
type NoteCreateStubResult struct {
	Note *sacloud.Note
	Err  error
}

// NoteReadStubResult is expected values of the Read operation
type NoteReadStubResult struct {
	Note *sacloud.Note
	Err  error
}

// NoteUpdateStubResult is expected values of the Update operation
type NoteUpdateStubResult struct {
	Note *sacloud.Note
	Err  error
}

// NoteDeleteStubResult is expected values of the Delete operation
type NoteDeleteStubResult struct {
	Err error
}

// NoteStub is for trace NoteOp operations
type NoteStub struct {
	FindStubResult   *NoteFindStubResult
	CreateStubResult *NoteCreateStubResult
	ReadStubResult   *NoteReadStubResult
	UpdateStubResult *NoteUpdateStubResult
	DeleteStubResult *NoteDeleteStubResult
}

// NewNoteStub creates new NoteStub instance
func NewNoteStub(caller sacloud.APICaller) sacloud.NoteAPI {
	return &NoteStub{}
}

// Find is API call with trace log
func (s *NoteStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.NoteFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("NoteStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *NoteStub) Create(ctx context.Context, param *sacloud.NoteCreateRequest) (*sacloud.Note, error) {
	if s.CreateStubResult == nil {
		log.Fatal("NoteStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.Note, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *NoteStub) Read(ctx context.Context, id types.ID) (*sacloud.Note, error) {
	if s.ReadStubResult == nil {
		log.Fatal("NoteStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Note, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *NoteStub) Update(ctx context.Context, id types.ID, param *sacloud.NoteUpdateRequest) (*sacloud.Note, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("NoteStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.Note, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *NoteStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("NoteStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* PacketFilterStub
*************************************************/

// PacketFilterFindStubResult is expected values of the Find operation
type PacketFilterFindStubResult struct {
	Values *sacloud.PacketFilterFindResult
	Err    error
}

// PacketFilterCreateStubResult is expected values of the Create operation
type PacketFilterCreateStubResult struct {
	PacketFilter *sacloud.PacketFilter
	Err          error
}

// PacketFilterReadStubResult is expected values of the Read operation
type PacketFilterReadStubResult struct {
	PacketFilter *sacloud.PacketFilter
	Err          error
}

// PacketFilterUpdateStubResult is expected values of the Update operation
type PacketFilterUpdateStubResult struct {
	PacketFilter *sacloud.PacketFilter
	Err          error
}

// PacketFilterDeleteStubResult is expected values of the Delete operation
type PacketFilterDeleteStubResult struct {
	Err error
}

// PacketFilterStub is for trace PacketFilterOp operations
type PacketFilterStub struct {
	FindStubResult   *PacketFilterFindStubResult
	CreateStubResult *PacketFilterCreateStubResult
	ReadStubResult   *PacketFilterReadStubResult
	UpdateStubResult *PacketFilterUpdateStubResult
	DeleteStubResult *PacketFilterDeleteStubResult
}

// NewPacketFilterStub creates new PacketFilterStub instance
func NewPacketFilterStub(caller sacloud.APICaller) sacloud.PacketFilterAPI {
	return &PacketFilterStub{}
}

// Find is API call with trace log
func (s *PacketFilterStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.PacketFilterFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("PacketFilterStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *PacketFilterStub) Create(ctx context.Context, zone string, param *sacloud.PacketFilterCreateRequest) (*sacloud.PacketFilter, error) {
	if s.CreateStubResult == nil {
		log.Fatal("PacketFilterStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.PacketFilter, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *PacketFilterStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.PacketFilter, error) {
	if s.ReadStubResult == nil {
		log.Fatal("PacketFilterStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.PacketFilter, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *PacketFilterStub) Update(ctx context.Context, zone string, id types.ID, updateParam *sacloud.PacketFilterUpdateRequest, originalExpressionHash string) (*sacloud.PacketFilter, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("PacketFilterStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.PacketFilter, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *PacketFilterStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("PacketFilterStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* PrivateHostStub
*************************************************/

// PrivateHostFindStubResult is expected values of the Find operation
type PrivateHostFindStubResult struct {
	Values *sacloud.PrivateHostFindResult
	Err    error
}

// PrivateHostCreateStubResult is expected values of the Create operation
type PrivateHostCreateStubResult struct {
	PrivateHost *sacloud.PrivateHost
	Err         error
}

// PrivateHostReadStubResult is expected values of the Read operation
type PrivateHostReadStubResult struct {
	PrivateHost *sacloud.PrivateHost
	Err         error
}

// PrivateHostUpdateStubResult is expected values of the Update operation
type PrivateHostUpdateStubResult struct {
	PrivateHost *sacloud.PrivateHost
	Err         error
}

// PrivateHostDeleteStubResult is expected values of the Delete operation
type PrivateHostDeleteStubResult struct {
	Err error
}

// PrivateHostStub is for trace PrivateHostOp operations
type PrivateHostStub struct {
	FindStubResult   *PrivateHostFindStubResult
	CreateStubResult *PrivateHostCreateStubResult
	ReadStubResult   *PrivateHostReadStubResult
	UpdateStubResult *PrivateHostUpdateStubResult
	DeleteStubResult *PrivateHostDeleteStubResult
}

// NewPrivateHostStub creates new PrivateHostStub instance
func NewPrivateHostStub(caller sacloud.APICaller) sacloud.PrivateHostAPI {
	return &PrivateHostStub{}
}

// Find is API call with trace log
func (s *PrivateHostStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.PrivateHostFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("PrivateHostStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *PrivateHostStub) Create(ctx context.Context, zone string, param *sacloud.PrivateHostCreateRequest) (*sacloud.PrivateHost, error) {
	if s.CreateStubResult == nil {
		log.Fatal("PrivateHostStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.PrivateHost, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *PrivateHostStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.PrivateHost, error) {
	if s.ReadStubResult == nil {
		log.Fatal("PrivateHostStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.PrivateHost, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *PrivateHostStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.PrivateHostUpdateRequest) (*sacloud.PrivateHost, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("PrivateHostStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.PrivateHost, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *PrivateHostStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("PrivateHostStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* PrivateHostPlanStub
*************************************************/

// PrivateHostPlanFindStubResult is expected values of the Find operation
type PrivateHostPlanFindStubResult struct {
	Values *sacloud.PrivateHostPlanFindResult
	Err    error
}

// PrivateHostPlanReadStubResult is expected values of the Read operation
type PrivateHostPlanReadStubResult struct {
	PrivateHostPlan *sacloud.PrivateHostPlan
	Err             error
}

// PrivateHostPlanStub is for trace PrivateHostPlanOp operations
type PrivateHostPlanStub struct {
	FindStubResult *PrivateHostPlanFindStubResult
	ReadStubResult *PrivateHostPlanReadStubResult
}

// NewPrivateHostPlanStub creates new PrivateHostPlanStub instance
func NewPrivateHostPlanStub(caller sacloud.APICaller) sacloud.PrivateHostPlanAPI {
	return &PrivateHostPlanStub{}
}

// Find is API call with trace log
func (s *PrivateHostPlanStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.PrivateHostPlanFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("PrivateHostPlanStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Read is API call with trace log
func (s *PrivateHostPlanStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.PrivateHostPlan, error) {
	if s.ReadStubResult == nil {
		log.Fatal("PrivateHostPlanStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.PrivateHostPlan, s.ReadStubResult.Err
}

/*************************************************
* ProxyLBStub
*************************************************/

// ProxyLBFindStubResult is expected values of the Find operation
type ProxyLBFindStubResult struct {
	Values *sacloud.ProxyLBFindResult
	Err    error
}

// ProxyLBCreateStubResult is expected values of the Create operation
type ProxyLBCreateStubResult struct {
	ProxyLB *sacloud.ProxyLB
	Err     error
}

// ProxyLBReadStubResult is expected values of the Read operation
type ProxyLBReadStubResult struct {
	ProxyLB *sacloud.ProxyLB
	Err     error
}

// ProxyLBUpdateStubResult is expected values of the Update operation
type ProxyLBUpdateStubResult struct {
	ProxyLB *sacloud.ProxyLB
	Err     error
}

// ProxyLBUpdateSettingsStubResult is expected values of the UpdateSettings operation
type ProxyLBUpdateSettingsStubResult struct {
	ProxyLB *sacloud.ProxyLB
	Err     error
}

// ProxyLBDeleteStubResult is expected values of the Delete operation
type ProxyLBDeleteStubResult struct {
	Err error
}

// ProxyLBChangePlanStubResult is expected values of the ChangePlan operation
type ProxyLBChangePlanStubResult struct {
	ProxyLB *sacloud.ProxyLB
	Err     error
}

// ProxyLBGetCertificatesStubResult is expected values of the GetCertificates operation
type ProxyLBGetCertificatesStubResult struct {
	ProxyLBCertificates *sacloud.ProxyLBCertificates
	Err                 error
}

// ProxyLBSetCertificatesStubResult is expected values of the SetCertificates operation
type ProxyLBSetCertificatesStubResult struct {
	ProxyLBCertificates *sacloud.ProxyLBCertificates
	Err                 error
}

// ProxyLBDeleteCertificatesStubResult is expected values of the DeleteCertificates operation
type ProxyLBDeleteCertificatesStubResult struct {
	Err error
}

// ProxyLBRenewLetsEncryptCertStubResult is expected values of the RenewLetsEncryptCert operation
type ProxyLBRenewLetsEncryptCertStubResult struct {
	Err error
}

// ProxyLBHealthStatusStubResult is expected values of the HealthStatus operation
type ProxyLBHealthStatusStubResult struct {
	ProxyLBHealth *sacloud.ProxyLBHealth
	Err           error
}

// ProxyLBMonitorConnectionStubResult is expected values of the MonitorConnection operation
type ProxyLBMonitorConnectionStubResult struct {
	ConnectionActivity *sacloud.ConnectionActivity
	Err                error
}

// ProxyLBStub is for trace ProxyLBOp operations
type ProxyLBStub struct {
	FindStubResult                 *ProxyLBFindStubResult
	CreateStubResult               *ProxyLBCreateStubResult
	ReadStubResult                 *ProxyLBReadStubResult
	UpdateStubResult               *ProxyLBUpdateStubResult
	UpdateSettingsStubResult       *ProxyLBUpdateSettingsStubResult
	DeleteStubResult               *ProxyLBDeleteStubResult
	ChangePlanStubResult           *ProxyLBChangePlanStubResult
	GetCertificatesStubResult      *ProxyLBGetCertificatesStubResult
	SetCertificatesStubResult      *ProxyLBSetCertificatesStubResult
	DeleteCertificatesStubResult   *ProxyLBDeleteCertificatesStubResult
	RenewLetsEncryptCertStubResult *ProxyLBRenewLetsEncryptCertStubResult
	HealthStatusStubResult         *ProxyLBHealthStatusStubResult
	MonitorConnectionStubResult    *ProxyLBMonitorConnectionStubResult
}

// NewProxyLBStub creates new ProxyLBStub instance
func NewProxyLBStub(caller sacloud.APICaller) sacloud.ProxyLBAPI {
	return &ProxyLBStub{}
}

// Find is API call with trace log
func (s *ProxyLBStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.ProxyLBFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("ProxyLBStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *ProxyLBStub) Create(ctx context.Context, param *sacloud.ProxyLBCreateRequest) (*sacloud.ProxyLB, error) {
	if s.CreateStubResult == nil {
		log.Fatal("ProxyLBStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.ProxyLB, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *ProxyLBStub) Read(ctx context.Context, id types.ID) (*sacloud.ProxyLB, error) {
	if s.ReadStubResult == nil {
		log.Fatal("ProxyLBStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.ProxyLB, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *ProxyLBStub) Update(ctx context.Context, id types.ID, param *sacloud.ProxyLBUpdateRequest) (*sacloud.ProxyLB, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("ProxyLBStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.ProxyLB, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *ProxyLBStub) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.ProxyLBUpdateSettingsRequest) (*sacloud.ProxyLB, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("ProxyLBStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.ProxyLB, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *ProxyLBStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("ProxyLBStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// ChangePlan is API call with trace log
func (s *ProxyLBStub) ChangePlan(ctx context.Context, id types.ID, param *sacloud.ProxyLBChangePlanRequest) (*sacloud.ProxyLB, error) {
	if s.ChangePlanStubResult == nil {
		log.Fatal("ProxyLBStub.ChangePlanStubResult is not set")
	}
	return s.ChangePlanStubResult.ProxyLB, s.ChangePlanStubResult.Err
}

// GetCertificates is API call with trace log
func (s *ProxyLBStub) GetCertificates(ctx context.Context, id types.ID) (*sacloud.ProxyLBCertificates, error) {
	if s.GetCertificatesStubResult == nil {
		log.Fatal("ProxyLBStub.GetCertificatesStubResult is not set")
	}
	return s.GetCertificatesStubResult.ProxyLBCertificates, s.GetCertificatesStubResult.Err
}

// SetCertificates is API call with trace log
func (s *ProxyLBStub) SetCertificates(ctx context.Context, id types.ID, param *sacloud.ProxyLBSetCertificatesRequest) (*sacloud.ProxyLBCertificates, error) {
	if s.SetCertificatesStubResult == nil {
		log.Fatal("ProxyLBStub.SetCertificatesStubResult is not set")
	}
	return s.SetCertificatesStubResult.ProxyLBCertificates, s.SetCertificatesStubResult.Err
}

// DeleteCertificates is API call with trace log
func (s *ProxyLBStub) DeleteCertificates(ctx context.Context, id types.ID) error {
	if s.DeleteCertificatesStubResult == nil {
		log.Fatal("ProxyLBStub.DeleteCertificatesStubResult is not set")
	}
	return s.DeleteCertificatesStubResult.Err
}

// RenewLetsEncryptCert is API call with trace log
func (s *ProxyLBStub) RenewLetsEncryptCert(ctx context.Context, id types.ID) error {
	if s.RenewLetsEncryptCertStubResult == nil {
		log.Fatal("ProxyLBStub.RenewLetsEncryptCertStubResult is not set")
	}
	return s.RenewLetsEncryptCertStubResult.Err
}

// HealthStatus is API call with trace log
func (s *ProxyLBStub) HealthStatus(ctx context.Context, id types.ID) (*sacloud.ProxyLBHealth, error) {
	if s.HealthStatusStubResult == nil {
		log.Fatal("ProxyLBStub.HealthStatusStubResult is not set")
	}
	return s.HealthStatusStubResult.ProxyLBHealth, s.HealthStatusStubResult.Err
}

// MonitorConnection is API call with trace log
func (s *ProxyLBStub) MonitorConnection(ctx context.Context, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.ConnectionActivity, error) {
	if s.MonitorConnectionStubResult == nil {
		log.Fatal("ProxyLBStub.MonitorConnectionStubResult is not set")
	}
	return s.MonitorConnectionStubResult.ConnectionActivity, s.MonitorConnectionStubResult.Err
}

/*************************************************
* RegionStub
*************************************************/

// RegionFindStubResult is expected values of the Find operation
type RegionFindStubResult struct {
	Values *sacloud.RegionFindResult
	Err    error
}

// RegionReadStubResult is expected values of the Read operation
type RegionReadStubResult struct {
	Region *sacloud.Region
	Err    error
}

// RegionStub is for trace RegionOp operations
type RegionStub struct {
	FindStubResult *RegionFindStubResult
	ReadStubResult *RegionReadStubResult
}

// NewRegionStub creates new RegionStub instance
func NewRegionStub(caller sacloud.APICaller) sacloud.RegionAPI {
	return &RegionStub{}
}

// Find is API call with trace log
func (s *RegionStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.RegionFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("RegionStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Read is API call with trace log
func (s *RegionStub) Read(ctx context.Context, id types.ID) (*sacloud.Region, error) {
	if s.ReadStubResult == nil {
		log.Fatal("RegionStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Region, s.ReadStubResult.Err
}

/*************************************************
* ServerStub
*************************************************/

// ServerFindStubResult is expected values of the Find operation
type ServerFindStubResult struct {
	Values *sacloud.ServerFindResult
	Err    error
}

// ServerCreateStubResult is expected values of the Create operation
type ServerCreateStubResult struct {
	Server *sacloud.Server
	Err    error
}

// ServerReadStubResult is expected values of the Read operation
type ServerReadStubResult struct {
	Server *sacloud.Server
	Err    error
}

// ServerUpdateStubResult is expected values of the Update operation
type ServerUpdateStubResult struct {
	Server *sacloud.Server
	Err    error
}

// ServerDeleteStubResult is expected values of the Delete operation
type ServerDeleteStubResult struct {
	Err error
}

// ServerDeleteWithDisksStubResult is expected values of the DeleteWithDisks operation
type ServerDeleteWithDisksStubResult struct {
	Err error
}

// ServerChangePlanStubResult is expected values of the ChangePlan operation
type ServerChangePlanStubResult struct {
	Server *sacloud.Server
	Err    error
}

// ServerInsertCDROMStubResult is expected values of the InsertCDROM operation
type ServerInsertCDROMStubResult struct {
	Err error
}

// ServerEjectCDROMStubResult is expected values of the EjectCDROM operation
type ServerEjectCDROMStubResult struct {
	Err error
}

// ServerBootStubResult is expected values of the Boot operation
type ServerBootStubResult struct {
	Err error
}

// ServerShutdownStubResult is expected values of the Shutdown operation
type ServerShutdownStubResult struct {
	Err error
}

// ServerResetStubResult is expected values of the Reset operation
type ServerResetStubResult struct {
	Err error
}

// ServerBootWithVariablesStubResult is expected values of the BootWithVariables operation
type ServerBootWithVariablesStubResult struct {
	Err error
}

// ServerSendKeyStubResult is expected values of the SendKey operation
type ServerSendKeyStubResult struct {
	Err error
}

// ServerSendNMIStubResult is expected values of the SendNMI operation
type ServerSendNMIStubResult struct {
	Err error
}

// ServerGetVNCProxyStubResult is expected values of the GetVNCProxy operation
type ServerGetVNCProxyStubResult struct {
	VNCProxyInfo *sacloud.VNCProxyInfo
	Err          error
}

// ServerMonitorStubResult is expected values of the Monitor operation
type ServerMonitorStubResult struct {
	CPUTimeActivity *sacloud.CPUTimeActivity
	Err             error
}

// ServerMonitorCPUStubResult is expected values of the MonitorCPU operation
type ServerMonitorCPUStubResult struct {
	CPUTimeActivity *sacloud.CPUTimeActivity
	Err             error
}

// ServerStub is for trace ServerOp operations
type ServerStub struct {
	FindStubResult              *ServerFindStubResult
	CreateStubResult            *ServerCreateStubResult
	ReadStubResult              *ServerReadStubResult
	UpdateStubResult            *ServerUpdateStubResult
	DeleteStubResult            *ServerDeleteStubResult
	DeleteWithDisksStubResult   *ServerDeleteWithDisksStubResult
	ChangePlanStubResult        *ServerChangePlanStubResult
	InsertCDROMStubResult       *ServerInsertCDROMStubResult
	EjectCDROMStubResult        *ServerEjectCDROMStubResult
	BootStubResult              *ServerBootStubResult
	ShutdownStubResult          *ServerShutdownStubResult
	ResetStubResult             *ServerResetStubResult
	BootWithVariablesStubResult *ServerBootWithVariablesStubResult
	SendKeyStubResult           *ServerSendKeyStubResult
	SendNMIStubResult           *ServerSendNMIStubResult
	GetVNCProxyStubResult       *ServerGetVNCProxyStubResult
	MonitorStubResult           *ServerMonitorStubResult
	MonitorCPUStubResult        *ServerMonitorCPUStubResult
}

// NewServerStub creates new ServerStub instance
func NewServerStub(caller sacloud.APICaller) sacloud.ServerAPI {
	return &ServerStub{}
}

// Find is API call with trace log
func (s *ServerStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.ServerFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("ServerStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *ServerStub) Create(ctx context.Context, zone string, param *sacloud.ServerCreateRequest) (*sacloud.Server, error) {
	if s.CreateStubResult == nil {
		log.Fatal("ServerStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.Server, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *ServerStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Server, error) {
	if s.ReadStubResult == nil {
		log.Fatal("ServerStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Server, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *ServerStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.ServerUpdateRequest) (*sacloud.Server, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("ServerStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.Server, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *ServerStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("ServerStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// DeleteWithDisks is API call with trace log
func (s *ServerStub) DeleteWithDisks(ctx context.Context, zone string, id types.ID, disks *sacloud.ServerDeleteWithDisksRequest) error {
	if s.DeleteWithDisksStubResult == nil {
		log.Fatal("ServerStub.DeleteWithDisksStubResult is not set")
	}
	return s.DeleteWithDisksStubResult.Err
}

// ChangePlan is API call with trace log
func (s *ServerStub) ChangePlan(ctx context.Context, zone string, id types.ID, plan *sacloud.ServerChangePlanRequest) (*sacloud.Server, error) {
	if s.ChangePlanStubResult == nil {
		log.Fatal("ServerStub.ChangePlanStubResult is not set")
	}
	return s.ChangePlanStubResult.Server, s.ChangePlanStubResult.Err
}

// InsertCDROM is API call with trace log
func (s *ServerStub) InsertCDROM(ctx context.Context, zone string, id types.ID, insertParam *sacloud.InsertCDROMRequest) error {
	if s.InsertCDROMStubResult == nil {
		log.Fatal("ServerStub.InsertCDROMStubResult is not set")
	}
	return s.InsertCDROMStubResult.Err
}

// EjectCDROM is API call with trace log
func (s *ServerStub) EjectCDROM(ctx context.Context, zone string, id types.ID, ejectParam *sacloud.EjectCDROMRequest) error {
	if s.EjectCDROMStubResult == nil {
		log.Fatal("ServerStub.EjectCDROMStubResult is not set")
	}
	return s.EjectCDROMStubResult.Err
}

// Boot is API call with trace log
func (s *ServerStub) Boot(ctx context.Context, zone string, id types.ID) error {
	if s.BootStubResult == nil {
		log.Fatal("ServerStub.BootStubResult is not set")
	}
	return s.BootStubResult.Err
}

// Shutdown is API call with trace log
func (s *ServerStub) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	if s.ShutdownStubResult == nil {
		log.Fatal("ServerStub.ShutdownStubResult is not set")
	}
	return s.ShutdownStubResult.Err
}

// Reset is API call with trace log
func (s *ServerStub) Reset(ctx context.Context, zone string, id types.ID) error {
	if s.ResetStubResult == nil {
		log.Fatal("ServerStub.ResetStubResult is not set")
	}
	return s.ResetStubResult.Err
}

// BootWithVariables is API call with trace log
func (s *ServerStub) BootWithVariables(ctx context.Context, zone string, id types.ID, param *sacloud.ServerBootVariables) error {
	if s.BootWithVariablesStubResult == nil {
		log.Fatal("ServerStub.BootWithVariablesStubResult is not set")
	}
	return s.BootWithVariablesStubResult.Err
}

// SendKey is API call with trace log
func (s *ServerStub) SendKey(ctx context.Context, zone string, id types.ID, keyboardParam *sacloud.SendKeyRequest) error {
	if s.SendKeyStubResult == nil {
		log.Fatal("ServerStub.SendKeyStubResult is not set")
	}
	return s.SendKeyStubResult.Err
}

// SendNMI is API call with trace log
func (s *ServerStub) SendNMI(ctx context.Context, zone string, id types.ID) error {
	if s.SendNMIStubResult == nil {
		log.Fatal("ServerStub.SendNMIStubResult is not set")
	}
	return s.SendNMIStubResult.Err
}

// GetVNCProxy is API call with trace log
func (s *ServerStub) GetVNCProxy(ctx context.Context, zone string, id types.ID) (*sacloud.VNCProxyInfo, error) {
	if s.GetVNCProxyStubResult == nil {
		log.Fatal("ServerStub.GetVNCProxyStubResult is not set")
	}
	return s.GetVNCProxyStubResult.VNCProxyInfo, s.GetVNCProxyStubResult.Err
}

// Monitor is API call with trace log
func (s *ServerStub) Monitor(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	if s.MonitorStubResult == nil {
		log.Fatal("ServerStub.MonitorStubResult is not set")
	}
	return s.MonitorStubResult.CPUTimeActivity, s.MonitorStubResult.Err
}

// MonitorCPU is API call with trace log
func (s *ServerStub) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	if s.MonitorCPUStubResult == nil {
		log.Fatal("ServerStub.MonitorCPUStubResult is not set")
	}
	return s.MonitorCPUStubResult.CPUTimeActivity, s.MonitorCPUStubResult.Err
}

/*************************************************
* ServerPlanStub
*************************************************/

// ServerPlanFindStubResult is expected values of the Find operation
type ServerPlanFindStubResult struct {
	Values *sacloud.ServerPlanFindResult
	Err    error
}

// ServerPlanReadStubResult is expected values of the Read operation
type ServerPlanReadStubResult struct {
	ServerPlan *sacloud.ServerPlan
	Err        error
}

// ServerPlanStub is for trace ServerPlanOp operations
type ServerPlanStub struct {
	FindStubResult *ServerPlanFindStubResult
	ReadStubResult *ServerPlanReadStubResult
}

// NewServerPlanStub creates new ServerPlanStub instance
func NewServerPlanStub(caller sacloud.APICaller) sacloud.ServerPlanAPI {
	return &ServerPlanStub{}
}

// Find is API call with trace log
func (s *ServerPlanStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.ServerPlanFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("ServerPlanStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Read is API call with trace log
func (s *ServerPlanStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.ServerPlan, error) {
	if s.ReadStubResult == nil {
		log.Fatal("ServerPlanStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.ServerPlan, s.ReadStubResult.Err
}

/*************************************************
* ServiceClassStub
*************************************************/

// ServiceClassFindStubResult is expected values of the Find operation
type ServiceClassFindStubResult struct {
	Values *sacloud.ServiceClassFindResult
	Err    error
}

// ServiceClassStub is for trace ServiceClassOp operations
type ServiceClassStub struct {
	FindStubResult *ServiceClassFindStubResult
}

// NewServiceClassStub creates new ServiceClassStub instance
func NewServiceClassStub(caller sacloud.APICaller) sacloud.ServiceClassAPI {
	return &ServiceClassStub{}
}

// Find is API call with trace log
func (s *ServiceClassStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.ServiceClassFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("ServiceClassStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

/*************************************************
* SIMStub
*************************************************/

// SIMFindStubResult is expected values of the Find operation
type SIMFindStubResult struct {
	Values *sacloud.SIMFindResult
	Err    error
}

// SIMCreateStubResult is expected values of the Create operation
type SIMCreateStubResult struct {
	SIM *sacloud.SIM
	Err error
}

// SIMReadStubResult is expected values of the Read operation
type SIMReadStubResult struct {
	SIM *sacloud.SIM
	Err error
}

// SIMUpdateStubResult is expected values of the Update operation
type SIMUpdateStubResult struct {
	SIM *sacloud.SIM
	Err error
}

// SIMDeleteStubResult is expected values of the Delete operation
type SIMDeleteStubResult struct {
	Err error
}

// SIMActivateStubResult is expected values of the Activate operation
type SIMActivateStubResult struct {
	Err error
}

// SIMDeactivateStubResult is expected values of the Deactivate operation
type SIMDeactivateStubResult struct {
	Err error
}

// SIMAssignIPStubResult is expected values of the AssignIP operation
type SIMAssignIPStubResult struct {
	Err error
}

// SIMClearIPStubResult is expected values of the ClearIP operation
type SIMClearIPStubResult struct {
	Err error
}

// SIMIMEILockStubResult is expected values of the IMEILock operation
type SIMIMEILockStubResult struct {
	Err error
}

// SIMIMEIUnlockStubResult is expected values of the IMEIUnlock operation
type SIMIMEIUnlockStubResult struct {
	Err error
}

// SIMLogsStubResult is expected values of the Logs operation
type SIMLogsStubResult struct {
	Values *sacloud.SIMLogsResult
	Err    error
}

// SIMGetNetworkOperatorStubResult is expected values of the GetNetworkOperator operation
type SIMGetNetworkOperatorStubResult struct {
	Configs []*sacloud.SIMNetworkOperatorConfig
	Err     error
}

// SIMSetNetworkOperatorStubResult is expected values of the SetNetworkOperator operation
type SIMSetNetworkOperatorStubResult struct {
	Err error
}

// SIMMonitorSIMStubResult is expected values of the MonitorSIM operation
type SIMMonitorSIMStubResult struct {
	LinkActivity *sacloud.LinkActivity
	Err          error
}

// SIMStatusStubResult is expected values of the Status operation
type SIMStatusStubResult struct {
	SIM *sacloud.SIMInfo
	Err error
}

// SIMStub is for trace SIMOp operations
type SIMStub struct {
	FindStubResult               *SIMFindStubResult
	CreateStubResult             *SIMCreateStubResult
	ReadStubResult               *SIMReadStubResult
	UpdateStubResult             *SIMUpdateStubResult
	DeleteStubResult             *SIMDeleteStubResult
	ActivateStubResult           *SIMActivateStubResult
	DeactivateStubResult         *SIMDeactivateStubResult
	AssignIPStubResult           *SIMAssignIPStubResult
	ClearIPStubResult            *SIMClearIPStubResult
	IMEILockStubResult           *SIMIMEILockStubResult
	IMEIUnlockStubResult         *SIMIMEIUnlockStubResult
	LogsStubResult               *SIMLogsStubResult
	GetNetworkOperatorStubResult *SIMGetNetworkOperatorStubResult
	SetNetworkOperatorStubResult *SIMSetNetworkOperatorStubResult
	MonitorSIMStubResult         *SIMMonitorSIMStubResult
	StatusStubResult             *SIMStatusStubResult
}

// NewSIMStub creates new SIMStub instance
func NewSIMStub(caller sacloud.APICaller) sacloud.SIMAPI {
	return &SIMStub{}
}

// Find is API call with trace log
func (s *SIMStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.SIMFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("SIMStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *SIMStub) Create(ctx context.Context, param *sacloud.SIMCreateRequest) (*sacloud.SIM, error) {
	if s.CreateStubResult == nil {
		log.Fatal("SIMStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.SIM, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *SIMStub) Read(ctx context.Context, id types.ID) (*sacloud.SIM, error) {
	if s.ReadStubResult == nil {
		log.Fatal("SIMStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.SIM, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *SIMStub) Update(ctx context.Context, id types.ID, param *sacloud.SIMUpdateRequest) (*sacloud.SIM, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("SIMStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.SIM, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *SIMStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("SIMStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// Activate is API call with trace log
func (s *SIMStub) Activate(ctx context.Context, id types.ID) error {
	if s.ActivateStubResult == nil {
		log.Fatal("SIMStub.ActivateStubResult is not set")
	}
	return s.ActivateStubResult.Err
}

// Deactivate is API call with trace log
func (s *SIMStub) Deactivate(ctx context.Context, id types.ID) error {
	if s.DeactivateStubResult == nil {
		log.Fatal("SIMStub.DeactivateStubResult is not set")
	}
	return s.DeactivateStubResult.Err
}

// AssignIP is API call with trace log
func (s *SIMStub) AssignIP(ctx context.Context, id types.ID, param *sacloud.SIMAssignIPRequest) error {
	if s.AssignIPStubResult == nil {
		log.Fatal("SIMStub.AssignIPStubResult is not set")
	}
	return s.AssignIPStubResult.Err
}

// ClearIP is API call with trace log
func (s *SIMStub) ClearIP(ctx context.Context, id types.ID) error {
	if s.ClearIPStubResult == nil {
		log.Fatal("SIMStub.ClearIPStubResult is not set")
	}
	return s.ClearIPStubResult.Err
}

// IMEILock is API call with trace log
func (s *SIMStub) IMEILock(ctx context.Context, id types.ID, param *sacloud.SIMIMEILockRequest) error {
	if s.IMEILockStubResult == nil {
		log.Fatal("SIMStub.IMEILockStubResult is not set")
	}
	return s.IMEILockStubResult.Err
}

// IMEIUnlock is API call with trace log
func (s *SIMStub) IMEIUnlock(ctx context.Context, id types.ID) error {
	if s.IMEIUnlockStubResult == nil {
		log.Fatal("SIMStub.IMEIUnlockStubResult is not set")
	}
	return s.IMEIUnlockStubResult.Err
}

// Logs is API call with trace log
func (s *SIMStub) Logs(ctx context.Context, id types.ID) (*sacloud.SIMLogsResult, error) {
	if s.LogsStubResult == nil {
		log.Fatal("SIMStub.LogsStubResult is not set")
	}
	return s.LogsStubResult.Values, s.LogsStubResult.Err
}

// GetNetworkOperator is API call with trace log
func (s *SIMStub) GetNetworkOperator(ctx context.Context, id types.ID) ([]*sacloud.SIMNetworkOperatorConfig, error) {
	if s.GetNetworkOperatorStubResult == nil {
		log.Fatal("SIMStub.GetNetworkOperatorStubResult is not set")
	}
	return s.GetNetworkOperatorStubResult.Configs, s.GetNetworkOperatorStubResult.Err
}

// SetNetworkOperator is API call with trace log
func (s *SIMStub) SetNetworkOperator(ctx context.Context, id types.ID, configs []*sacloud.SIMNetworkOperatorConfig) error {
	if s.SetNetworkOperatorStubResult == nil {
		log.Fatal("SIMStub.SetNetworkOperatorStubResult is not set")
	}
	return s.SetNetworkOperatorStubResult.Err
}

// MonitorSIM is API call with trace log
func (s *SIMStub) MonitorSIM(ctx context.Context, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.LinkActivity, error) {
	if s.MonitorSIMStubResult == nil {
		log.Fatal("SIMStub.MonitorSIMStubResult is not set")
	}
	return s.MonitorSIMStubResult.LinkActivity, s.MonitorSIMStubResult.Err
}

// Status is API call with trace log
func (s *SIMStub) Status(ctx context.Context, id types.ID) (*sacloud.SIMInfo, error) {
	if s.StatusStubResult == nil {
		log.Fatal("SIMStub.StatusStubResult is not set")
	}
	return s.StatusStubResult.SIM, s.StatusStubResult.Err
}

/*************************************************
* SimpleMonitorStub
*************************************************/

// SimpleMonitorFindStubResult is expected values of the Find operation
type SimpleMonitorFindStubResult struct {
	Values *sacloud.SimpleMonitorFindResult
	Err    error
}

// SimpleMonitorCreateStubResult is expected values of the Create operation
type SimpleMonitorCreateStubResult struct {
	SimpleMonitor *sacloud.SimpleMonitor
	Err           error
}

// SimpleMonitorReadStubResult is expected values of the Read operation
type SimpleMonitorReadStubResult struct {
	SimpleMonitor *sacloud.SimpleMonitor
	Err           error
}

// SimpleMonitorUpdateStubResult is expected values of the Update operation
type SimpleMonitorUpdateStubResult struct {
	SimpleMonitor *sacloud.SimpleMonitor
	Err           error
}

// SimpleMonitorUpdateSettingsStubResult is expected values of the UpdateSettings operation
type SimpleMonitorUpdateSettingsStubResult struct {
	SimpleMonitor *sacloud.SimpleMonitor
	Err           error
}

// SimpleMonitorDeleteStubResult is expected values of the Delete operation
type SimpleMonitorDeleteStubResult struct {
	Err error
}

// SimpleMonitorMonitorResponseTimeStubResult is expected values of the MonitorResponseTime operation
type SimpleMonitorMonitorResponseTimeStubResult struct {
	ResponseTimeSecActivity *sacloud.ResponseTimeSecActivity
	Err                     error
}

// SimpleMonitorHealthStatusStubResult is expected values of the HealthStatus operation
type SimpleMonitorHealthStatusStubResult struct {
	SimpleMonitorHealthStatus *sacloud.SimpleMonitorHealthStatus
	Err                       error
}

// SimpleMonitorStub is for trace SimpleMonitorOp operations
type SimpleMonitorStub struct {
	FindStubResult                *SimpleMonitorFindStubResult
	CreateStubResult              *SimpleMonitorCreateStubResult
	ReadStubResult                *SimpleMonitorReadStubResult
	UpdateStubResult              *SimpleMonitorUpdateStubResult
	UpdateSettingsStubResult      *SimpleMonitorUpdateSettingsStubResult
	DeleteStubResult              *SimpleMonitorDeleteStubResult
	MonitorResponseTimeStubResult *SimpleMonitorMonitorResponseTimeStubResult
	HealthStatusStubResult        *SimpleMonitorHealthStatusStubResult
}

// NewSimpleMonitorStub creates new SimpleMonitorStub instance
func NewSimpleMonitorStub(caller sacloud.APICaller) sacloud.SimpleMonitorAPI {
	return &SimpleMonitorStub{}
}

// Find is API call with trace log
func (s *SimpleMonitorStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.SimpleMonitorFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("SimpleMonitorStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *SimpleMonitorStub) Create(ctx context.Context, param *sacloud.SimpleMonitorCreateRequest) (*sacloud.SimpleMonitor, error) {
	if s.CreateStubResult == nil {
		log.Fatal("SimpleMonitorStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.SimpleMonitor, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *SimpleMonitorStub) Read(ctx context.Context, id types.ID) (*sacloud.SimpleMonitor, error) {
	if s.ReadStubResult == nil {
		log.Fatal("SimpleMonitorStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.SimpleMonitor, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *SimpleMonitorStub) Update(ctx context.Context, id types.ID, param *sacloud.SimpleMonitorUpdateRequest) (*sacloud.SimpleMonitor, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("SimpleMonitorStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.SimpleMonitor, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *SimpleMonitorStub) UpdateSettings(ctx context.Context, id types.ID, param *sacloud.SimpleMonitorUpdateSettingsRequest) (*sacloud.SimpleMonitor, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("SimpleMonitorStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.SimpleMonitor, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *SimpleMonitorStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("SimpleMonitorStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// MonitorResponseTime is API call with trace log
func (s *SimpleMonitorStub) MonitorResponseTime(ctx context.Context, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.ResponseTimeSecActivity, error) {
	if s.MonitorResponseTimeStubResult == nil {
		log.Fatal("SimpleMonitorStub.MonitorResponseTimeStubResult is not set")
	}
	return s.MonitorResponseTimeStubResult.ResponseTimeSecActivity, s.MonitorResponseTimeStubResult.Err
}

// HealthStatus is API call with trace log
func (s *SimpleMonitorStub) HealthStatus(ctx context.Context, id types.ID) (*sacloud.SimpleMonitorHealthStatus, error) {
	if s.HealthStatusStubResult == nil {
		log.Fatal("SimpleMonitorStub.HealthStatusStubResult is not set")
	}
	return s.HealthStatusStubResult.SimpleMonitorHealthStatus, s.HealthStatusStubResult.Err
}

/*************************************************
* SSHKeyStub
*************************************************/

// SSHKeyFindStubResult is expected values of the Find operation
type SSHKeyFindStubResult struct {
	Values *sacloud.SSHKeyFindResult
	Err    error
}

// SSHKeyCreateStubResult is expected values of the Create operation
type SSHKeyCreateStubResult struct {
	SSHKey *sacloud.SSHKey
	Err    error
}

// SSHKeyGenerateStubResult is expected values of the Generate operation
type SSHKeyGenerateStubResult struct {
	SSHKeyGenerated *sacloud.SSHKeyGenerated
	Err             error
}

// SSHKeyReadStubResult is expected values of the Read operation
type SSHKeyReadStubResult struct {
	SSHKey *sacloud.SSHKey
	Err    error
}

// SSHKeyUpdateStubResult is expected values of the Update operation
type SSHKeyUpdateStubResult struct {
	SSHKey *sacloud.SSHKey
	Err    error
}

// SSHKeyDeleteStubResult is expected values of the Delete operation
type SSHKeyDeleteStubResult struct {
	Err error
}

// SSHKeyStub is for trace SSHKeyOp operations
type SSHKeyStub struct {
	FindStubResult     *SSHKeyFindStubResult
	CreateStubResult   *SSHKeyCreateStubResult
	GenerateStubResult *SSHKeyGenerateStubResult
	ReadStubResult     *SSHKeyReadStubResult
	UpdateStubResult   *SSHKeyUpdateStubResult
	DeleteStubResult   *SSHKeyDeleteStubResult
}

// NewSSHKeyStub creates new SSHKeyStub instance
func NewSSHKeyStub(caller sacloud.APICaller) sacloud.SSHKeyAPI {
	return &SSHKeyStub{}
}

// Find is API call with trace log
func (s *SSHKeyStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.SSHKeyFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("SSHKeyStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *SSHKeyStub) Create(ctx context.Context, param *sacloud.SSHKeyCreateRequest) (*sacloud.SSHKey, error) {
	if s.CreateStubResult == nil {
		log.Fatal("SSHKeyStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.SSHKey, s.CreateStubResult.Err
}

// Generate is API call with trace log
func (s *SSHKeyStub) Generate(ctx context.Context, param *sacloud.SSHKeyGenerateRequest) (*sacloud.SSHKeyGenerated, error) {
	if s.GenerateStubResult == nil {
		log.Fatal("SSHKeyStub.GenerateStubResult is not set")
	}
	return s.GenerateStubResult.SSHKeyGenerated, s.GenerateStubResult.Err
}

// Read is API call with trace log
func (s *SSHKeyStub) Read(ctx context.Context, id types.ID) (*sacloud.SSHKey, error) {
	if s.ReadStubResult == nil {
		log.Fatal("SSHKeyStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.SSHKey, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *SSHKeyStub) Update(ctx context.Context, id types.ID, param *sacloud.SSHKeyUpdateRequest) (*sacloud.SSHKey, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("SSHKeyStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.SSHKey, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *SSHKeyStub) Delete(ctx context.Context, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("SSHKeyStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

/*************************************************
* SubnetStub
*************************************************/

// SubnetFindStubResult is expected values of the Find operation
type SubnetFindStubResult struct {
	Values *sacloud.SubnetFindResult
	Err    error
}

// SubnetReadStubResult is expected values of the Read operation
type SubnetReadStubResult struct {
	Subnet *sacloud.Subnet
	Err    error
}

// SubnetStub is for trace SubnetOp operations
type SubnetStub struct {
	FindStubResult *SubnetFindStubResult
	ReadStubResult *SubnetReadStubResult
}

// NewSubnetStub creates new SubnetStub instance
func NewSubnetStub(caller sacloud.APICaller) sacloud.SubnetAPI {
	return &SubnetStub{}
}

// Find is API call with trace log
func (s *SubnetStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.SubnetFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("SubnetStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Read is API call with trace log
func (s *SubnetStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Subnet, error) {
	if s.ReadStubResult == nil {
		log.Fatal("SubnetStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Subnet, s.ReadStubResult.Err
}

/*************************************************
* SwitchStub
*************************************************/

// SwitchFindStubResult is expected values of the Find operation
type SwitchFindStubResult struct {
	Values *sacloud.SwitchFindResult
	Err    error
}

// SwitchCreateStubResult is expected values of the Create operation
type SwitchCreateStubResult struct {
	Switch *sacloud.Switch
	Err    error
}

// SwitchReadStubResult is expected values of the Read operation
type SwitchReadStubResult struct {
	Switch *sacloud.Switch
	Err    error
}

// SwitchUpdateStubResult is expected values of the Update operation
type SwitchUpdateStubResult struct {
	Switch *sacloud.Switch
	Err    error
}

// SwitchDeleteStubResult is expected values of the Delete operation
type SwitchDeleteStubResult struct {
	Err error
}

// SwitchConnectToBridgeStubResult is expected values of the ConnectToBridge operation
type SwitchConnectToBridgeStubResult struct {
	Err error
}

// SwitchDisconnectFromBridgeStubResult is expected values of the DisconnectFromBridge operation
type SwitchDisconnectFromBridgeStubResult struct {
	Err error
}

// SwitchGetServersStubResult is expected values of the GetServers operation
type SwitchGetServersStubResult struct {
	Values *sacloud.SwitchGetServersResult
	Err    error
}

// SwitchStub is for trace SwitchOp operations
type SwitchStub struct {
	FindStubResult                 *SwitchFindStubResult
	CreateStubResult               *SwitchCreateStubResult
	ReadStubResult                 *SwitchReadStubResult
	UpdateStubResult               *SwitchUpdateStubResult
	DeleteStubResult               *SwitchDeleteStubResult
	ConnectToBridgeStubResult      *SwitchConnectToBridgeStubResult
	DisconnectFromBridgeStubResult *SwitchDisconnectFromBridgeStubResult
	GetServersStubResult           *SwitchGetServersStubResult
}

// NewSwitchStub creates new SwitchStub instance
func NewSwitchStub(caller sacloud.APICaller) sacloud.SwitchAPI {
	return &SwitchStub{}
}

// Find is API call with trace log
func (s *SwitchStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.SwitchFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("SwitchStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *SwitchStub) Create(ctx context.Context, zone string, param *sacloud.SwitchCreateRequest) (*sacloud.Switch, error) {
	if s.CreateStubResult == nil {
		log.Fatal("SwitchStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.Switch, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *SwitchStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.Switch, error) {
	if s.ReadStubResult == nil {
		log.Fatal("SwitchStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Switch, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *SwitchStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.SwitchUpdateRequest) (*sacloud.Switch, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("SwitchStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.Switch, s.UpdateStubResult.Err
}

// Delete is API call with trace log
func (s *SwitchStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("SwitchStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// ConnectToBridge is API call with trace log
func (s *SwitchStub) ConnectToBridge(ctx context.Context, zone string, id types.ID, bridgeID types.ID) error {
	if s.ConnectToBridgeStubResult == nil {
		log.Fatal("SwitchStub.ConnectToBridgeStubResult is not set")
	}
	return s.ConnectToBridgeStubResult.Err
}

// DisconnectFromBridge is API call with trace log
func (s *SwitchStub) DisconnectFromBridge(ctx context.Context, zone string, id types.ID) error {
	if s.DisconnectFromBridgeStubResult == nil {
		log.Fatal("SwitchStub.DisconnectFromBridgeStubResult is not set")
	}
	return s.DisconnectFromBridgeStubResult.Err
}

// GetServers is API call with trace log
func (s *SwitchStub) GetServers(ctx context.Context, zone string, id types.ID) (*sacloud.SwitchGetServersResult, error) {
	if s.GetServersStubResult == nil {
		log.Fatal("SwitchStub.GetServersStubResult is not set")
	}
	return s.GetServersStubResult.Values, s.GetServersStubResult.Err
}

/*************************************************
* VPCRouterStub
*************************************************/

// VPCRouterFindStubResult is expected values of the Find operation
type VPCRouterFindStubResult struct {
	Values *sacloud.VPCRouterFindResult
	Err    error
}

// VPCRouterCreateStubResult is expected values of the Create operation
type VPCRouterCreateStubResult struct {
	VPCRouter *sacloud.VPCRouter
	Err       error
}

// VPCRouterReadStubResult is expected values of the Read operation
type VPCRouterReadStubResult struct {
	VPCRouter *sacloud.VPCRouter
	Err       error
}

// VPCRouterUpdateStubResult is expected values of the Update operation
type VPCRouterUpdateStubResult struct {
	VPCRouter *sacloud.VPCRouter
	Err       error
}

// VPCRouterUpdateSettingsStubResult is expected values of the UpdateSettings operation
type VPCRouterUpdateSettingsStubResult struct {
	VPCRouter *sacloud.VPCRouter
	Err       error
}

// VPCRouterDeleteStubResult is expected values of the Delete operation
type VPCRouterDeleteStubResult struct {
	Err error
}

// VPCRouterConfigStubResult is expected values of the Config operation
type VPCRouterConfigStubResult struct {
	Err error
}

// VPCRouterBootStubResult is expected values of the Boot operation
type VPCRouterBootStubResult struct {
	Err error
}

// VPCRouterShutdownStubResult is expected values of the Shutdown operation
type VPCRouterShutdownStubResult struct {
	Err error
}

// VPCRouterResetStubResult is expected values of the Reset operation
type VPCRouterResetStubResult struct {
	Err error
}

// VPCRouterConnectToSwitchStubResult is expected values of the ConnectToSwitch operation
type VPCRouterConnectToSwitchStubResult struct {
	Err error
}

// VPCRouterDisconnectFromSwitchStubResult is expected values of the DisconnectFromSwitch operation
type VPCRouterDisconnectFromSwitchStubResult struct {
	Err error
}

// VPCRouterMonitorCPUStubResult is expected values of the MonitorCPU operation
type VPCRouterMonitorCPUStubResult struct {
	CPUTimeActivity *sacloud.CPUTimeActivity
	Err             error
}

// VPCRouterMonitorInterfaceStubResult is expected values of the MonitorInterface operation
type VPCRouterMonitorInterfaceStubResult struct {
	InterfaceActivity *sacloud.InterfaceActivity
	Err               error
}

// VPCRouterStatusStubResult is expected values of the Status operation
type VPCRouterStatusStubResult struct {
	VPCRouterStatus *sacloud.VPCRouterStatus
	Err             error
}

// VPCRouterStub is for trace VPCRouterOp operations
type VPCRouterStub struct {
	FindStubResult                 *VPCRouterFindStubResult
	CreateStubResult               *VPCRouterCreateStubResult
	ReadStubResult                 *VPCRouterReadStubResult
	UpdateStubResult               *VPCRouterUpdateStubResult
	UpdateSettingsStubResult       *VPCRouterUpdateSettingsStubResult
	DeleteStubResult               *VPCRouterDeleteStubResult
	ConfigStubResult               *VPCRouterConfigStubResult
	BootStubResult                 *VPCRouterBootStubResult
	ShutdownStubResult             *VPCRouterShutdownStubResult
	ResetStubResult                *VPCRouterResetStubResult
	ConnectToSwitchStubResult      *VPCRouterConnectToSwitchStubResult
	DisconnectFromSwitchStubResult *VPCRouterDisconnectFromSwitchStubResult
	MonitorCPUStubResult           *VPCRouterMonitorCPUStubResult
	MonitorInterfaceStubResult     *VPCRouterMonitorInterfaceStubResult
	StatusStubResult               *VPCRouterStatusStubResult
}

// NewVPCRouterStub creates new VPCRouterStub instance
func NewVPCRouterStub(caller sacloud.APICaller) sacloud.VPCRouterAPI {
	return &VPCRouterStub{}
}

// Find is API call with trace log
func (s *VPCRouterStub) Find(ctx context.Context, zone string, conditions *sacloud.FindCondition) (*sacloud.VPCRouterFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("VPCRouterStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Create is API call with trace log
func (s *VPCRouterStub) Create(ctx context.Context, zone string, param *sacloud.VPCRouterCreateRequest) (*sacloud.VPCRouter, error) {
	if s.CreateStubResult == nil {
		log.Fatal("VPCRouterStub.CreateStubResult is not set")
	}
	return s.CreateStubResult.VPCRouter, s.CreateStubResult.Err
}

// Read is API call with trace log
func (s *VPCRouterStub) Read(ctx context.Context, zone string, id types.ID) (*sacloud.VPCRouter, error) {
	if s.ReadStubResult == nil {
		log.Fatal("VPCRouterStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.VPCRouter, s.ReadStubResult.Err
}

// Update is API call with trace log
func (s *VPCRouterStub) Update(ctx context.Context, zone string, id types.ID, param *sacloud.VPCRouterUpdateRequest) (*sacloud.VPCRouter, error) {
	if s.UpdateStubResult == nil {
		log.Fatal("VPCRouterStub.UpdateStubResult is not set")
	}
	return s.UpdateStubResult.VPCRouter, s.UpdateStubResult.Err
}

// UpdateSettings is API call with trace log
func (s *VPCRouterStub) UpdateSettings(ctx context.Context, zone string, id types.ID, param *sacloud.VPCRouterUpdateSettingsRequest) (*sacloud.VPCRouter, error) {
	if s.UpdateSettingsStubResult == nil {
		log.Fatal("VPCRouterStub.UpdateSettingsStubResult is not set")
	}
	return s.UpdateSettingsStubResult.VPCRouter, s.UpdateSettingsStubResult.Err
}

// Delete is API call with trace log
func (s *VPCRouterStub) Delete(ctx context.Context, zone string, id types.ID) error {
	if s.DeleteStubResult == nil {
		log.Fatal("VPCRouterStub.DeleteStubResult is not set")
	}
	return s.DeleteStubResult.Err
}

// Config is API call with trace log
func (s *VPCRouterStub) Config(ctx context.Context, zone string, id types.ID) error {
	if s.ConfigStubResult == nil {
		log.Fatal("VPCRouterStub.ConfigStubResult is not set")
	}
	return s.ConfigStubResult.Err
}

// Boot is API call with trace log
func (s *VPCRouterStub) Boot(ctx context.Context, zone string, id types.ID) error {
	if s.BootStubResult == nil {
		log.Fatal("VPCRouterStub.BootStubResult is not set")
	}
	return s.BootStubResult.Err
}

// Shutdown is API call with trace log
func (s *VPCRouterStub) Shutdown(ctx context.Context, zone string, id types.ID, shutdownOption *sacloud.ShutdownOption) error {
	if s.ShutdownStubResult == nil {
		log.Fatal("VPCRouterStub.ShutdownStubResult is not set")
	}
	return s.ShutdownStubResult.Err
}

// Reset is API call with trace log
func (s *VPCRouterStub) Reset(ctx context.Context, zone string, id types.ID) error {
	if s.ResetStubResult == nil {
		log.Fatal("VPCRouterStub.ResetStubResult is not set")
	}
	return s.ResetStubResult.Err
}

// ConnectToSwitch is API call with trace log
func (s *VPCRouterStub) ConnectToSwitch(ctx context.Context, zone string, id types.ID, nicIndex int, switchID types.ID) error {
	if s.ConnectToSwitchStubResult == nil {
		log.Fatal("VPCRouterStub.ConnectToSwitchStubResult is not set")
	}
	return s.ConnectToSwitchStubResult.Err
}

// DisconnectFromSwitch is API call with trace log
func (s *VPCRouterStub) DisconnectFromSwitch(ctx context.Context, zone string, id types.ID, nicIndex int) error {
	if s.DisconnectFromSwitchStubResult == nil {
		log.Fatal("VPCRouterStub.DisconnectFromSwitchStubResult is not set")
	}
	return s.DisconnectFromSwitchStubResult.Err
}

// MonitorCPU is API call with trace log
func (s *VPCRouterStub) MonitorCPU(ctx context.Context, zone string, id types.ID, condition *sacloud.MonitorCondition) (*sacloud.CPUTimeActivity, error) {
	if s.MonitorCPUStubResult == nil {
		log.Fatal("VPCRouterStub.MonitorCPUStubResult is not set")
	}
	return s.MonitorCPUStubResult.CPUTimeActivity, s.MonitorCPUStubResult.Err
}

// MonitorInterface is API call with trace log
func (s *VPCRouterStub) MonitorInterface(ctx context.Context, zone string, id types.ID, index int, condition *sacloud.MonitorCondition) (*sacloud.InterfaceActivity, error) {
	if s.MonitorInterfaceStubResult == nil {
		log.Fatal("VPCRouterStub.MonitorInterfaceStubResult is not set")
	}
	return s.MonitorInterfaceStubResult.InterfaceActivity, s.MonitorInterfaceStubResult.Err
}

// Status is API call with trace log
func (s *VPCRouterStub) Status(ctx context.Context, zone string, id types.ID) (*sacloud.VPCRouterStatus, error) {
	if s.StatusStubResult == nil {
		log.Fatal("VPCRouterStub.StatusStubResult is not set")
	}
	return s.StatusStubResult.VPCRouterStatus, s.StatusStubResult.Err
}

/*************************************************
* WebAccelStub
*************************************************/

// WebAccelListStubResult is expected values of the List operation
type WebAccelListStubResult struct {
	Values *sacloud.WebAccelListResult
	Err    error
}

// WebAccelReadStubResult is expected values of the Read operation
type WebAccelReadStubResult struct {
	WebAccel *sacloud.WebAccel
	Err      error
}

// WebAccelReadCertificateStubResult is expected values of the ReadCertificate operation
type WebAccelReadCertificateStubResult struct {
	Certificate *sacloud.WebAccelCerts
	Err         error
}

// WebAccelCreateCertificateStubResult is expected values of the CreateCertificate operation
type WebAccelCreateCertificateStubResult struct {
	Certificate *sacloud.WebAccelCerts
	Err         error
}

// WebAccelUpdateCertificateStubResult is expected values of the UpdateCertificate operation
type WebAccelUpdateCertificateStubResult struct {
	Certificate *sacloud.WebAccelCerts
	Err         error
}

// WebAccelDeleteCertificateStubResult is expected values of the DeleteCertificate operation
type WebAccelDeleteCertificateStubResult struct {
	Err error
}

// WebAccelDeleteAllCacheStubResult is expected values of the DeleteAllCache operation
type WebAccelDeleteAllCacheStubResult struct {
	Err error
}

// WebAccelDeleteCacheStubResult is expected values of the DeleteCache operation
type WebAccelDeleteCacheStubResult struct {
	Results []*sacloud.WebAccelDeleteCacheResult
	Err     error
}

// WebAccelStub is for trace WebAccelOp operations
type WebAccelStub struct {
	ListStubResult              *WebAccelListStubResult
	ReadStubResult              *WebAccelReadStubResult
	ReadCertificateStubResult   *WebAccelReadCertificateStubResult
	CreateCertificateStubResult *WebAccelCreateCertificateStubResult
	UpdateCertificateStubResult *WebAccelUpdateCertificateStubResult
	DeleteCertificateStubResult *WebAccelDeleteCertificateStubResult
	DeleteAllCacheStubResult    *WebAccelDeleteAllCacheStubResult
	DeleteCacheStubResult       *WebAccelDeleteCacheStubResult
}

// NewWebAccelStub creates new WebAccelStub instance
func NewWebAccelStub(caller sacloud.APICaller) sacloud.WebAccelAPI {
	return &WebAccelStub{}
}

// List is API call with trace log
func (s *WebAccelStub) List(ctx context.Context) (*sacloud.WebAccelListResult, error) {
	if s.ListStubResult == nil {
		log.Fatal("WebAccelStub.ListStubResult is not set")
	}
	return s.ListStubResult.Values, s.ListStubResult.Err
}

// Read is API call with trace log
func (s *WebAccelStub) Read(ctx context.Context, id types.ID) (*sacloud.WebAccel, error) {
	if s.ReadStubResult == nil {
		log.Fatal("WebAccelStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.WebAccel, s.ReadStubResult.Err
}

// ReadCertificate is API call with trace log
func (s *WebAccelStub) ReadCertificate(ctx context.Context, id types.ID) (*sacloud.WebAccelCerts, error) {
	if s.ReadCertificateStubResult == nil {
		log.Fatal("WebAccelStub.ReadCertificateStubResult is not set")
	}
	return s.ReadCertificateStubResult.Certificate, s.ReadCertificateStubResult.Err
}

// CreateCertificate is API call with trace log
func (s *WebAccelStub) CreateCertificate(ctx context.Context, id types.ID, param *sacloud.WebAccelCertRequest) (*sacloud.WebAccelCerts, error) {
	if s.CreateCertificateStubResult == nil {
		log.Fatal("WebAccelStub.CreateCertificateStubResult is not set")
	}
	return s.CreateCertificateStubResult.Certificate, s.CreateCertificateStubResult.Err
}

// UpdateCertificate is API call with trace log
func (s *WebAccelStub) UpdateCertificate(ctx context.Context, id types.ID, param *sacloud.WebAccelCertRequest) (*sacloud.WebAccelCerts, error) {
	if s.UpdateCertificateStubResult == nil {
		log.Fatal("WebAccelStub.UpdateCertificateStubResult is not set")
	}
	return s.UpdateCertificateStubResult.Certificate, s.UpdateCertificateStubResult.Err
}

// DeleteCertificate is API call with trace log
func (s *WebAccelStub) DeleteCertificate(ctx context.Context, id types.ID) error {
	if s.DeleteCertificateStubResult == nil {
		log.Fatal("WebAccelStub.DeleteCertificateStubResult is not set")
	}
	return s.DeleteCertificateStubResult.Err
}

// DeleteAllCache is API call with trace log
func (s *WebAccelStub) DeleteAllCache(ctx context.Context, param *sacloud.WebAccelDeleteAllCacheRequest) error {
	if s.DeleteAllCacheStubResult == nil {
		log.Fatal("WebAccelStub.DeleteAllCacheStubResult is not set")
	}
	return s.DeleteAllCacheStubResult.Err
}

// DeleteCache is API call with trace log
func (s *WebAccelStub) DeleteCache(ctx context.Context, param *sacloud.WebAccelDeleteCacheRequest) ([]*sacloud.WebAccelDeleteCacheResult, error) {
	if s.DeleteCacheStubResult == nil {
		log.Fatal("WebAccelStub.DeleteCacheStubResult is not set")
	}
	return s.DeleteCacheStubResult.Results, s.DeleteCacheStubResult.Err
}

/*************************************************
* ZoneStub
*************************************************/

// ZoneFindStubResult is expected values of the Find operation
type ZoneFindStubResult struct {
	Values *sacloud.ZoneFindResult
	Err    error
}

// ZoneReadStubResult is expected values of the Read operation
type ZoneReadStubResult struct {
	Zone *sacloud.Zone
	Err  error
}

// ZoneStub is for trace ZoneOp operations
type ZoneStub struct {
	FindStubResult *ZoneFindStubResult
	ReadStubResult *ZoneReadStubResult
}

// NewZoneStub creates new ZoneStub instance
func NewZoneStub(caller sacloud.APICaller) sacloud.ZoneAPI {
	return &ZoneStub{}
}

// Find is API call with trace log
func (s *ZoneStub) Find(ctx context.Context, conditions *sacloud.FindCondition) (*sacloud.ZoneFindResult, error) {
	if s.FindStubResult == nil {
		log.Fatal("ZoneStub.FindStubResult is not set")
	}
	return s.FindStubResult.Values, s.FindStubResult.Err
}

// Read is API call with trace log
func (s *ZoneStub) Read(ctx context.Context, id types.ID) (*sacloud.Zone, error) {
	if s.ReadStubResult == nil {
		log.Fatal("ZoneStub.ReadStubResult is not set")
	}
	return s.ReadStubResult.Zone, s.ReadStubResult.Err
}
